Table of Contents

4
9
16
22
28
34
42
51
62
68
70
78
85
88
92
99
106
114
123
132
141
150
161
172
184
195
206
209
212
215
218
221
225
236
248
253
260
272
279
293
302
309
316
323
331
340
348
356
364
372
381
389
398
405
412
419
424
427
431
434
437
444
451
460
462
465
470
477
484
489
492
497
502
506
511
514
518
522
526
530
536
546
554
561
564
567
570
573
577
580
585
592
598
605
606
610
613
618

Bem-vindo ao Git Pie 🥧

O que é o Git Pie?

Git Pie é um guia completo sobre Git e controle de versão, criado especialmente para desenvolvedores brasileiros. Nossa proposta é ensinar Git de forma clara, objetiva e com uma pitada de humor.

Como Usar esta Documentação

Caminho Recomendado

Você está aqui

Fundamentos

Prática Diária

Workflows

Avançado

Enterprise

1. Fundamentos First 🎯

Se você está começando:

  • Conceitos Básicos do Git

  • Instalação e Configuração

  • Primeiros Comandos

  • Ciclo de Vida do Git

2. Mão na Massa 💪

Aprenda o dia a dia:

  • Commits e Boas Práticas

  • Branches na Prática

  • Resolução de Conflitos

  • Code Review

3. Workflows na Vida Real 🌍

Escolha seu caminho:

  • Trunk-Based Development

  • Feature Branch

  • Gitflow

  • Forking Workflow

4. Nível Avançado 🚀

Para os ninjas do Git:

  • Git Internals

  • Hooks e Automação

  • Recuperação com Reflog

  • Submodules e Subtrees

5. Enterprise Ready 🏢

Escalando para times grandes:

  • Governança

  • Segurança

  • Performance

  • Métricas

Highlights do Conteúdo

Must-Know

EssenciaisCommitsBranchesMergePull Request

Quick Wins 🏃

  • Comandos mais usados

  • Fluxo básico de trabalho

  • Resolução de conflitos simples

  • Boas práticas de commit

Power Features 💪

  • Rebase interativo

  • Cherry-pick

  • Bisect

  • Hooks

Por Onde Começar?

Iniciante Total

  1. Conceitos Básicos (Conceitos Básicos do Git)

  2. Instalação e Setup (Instalação e Setup)

  3. Primeiros Passos (Primeiros Passos)

Já Uso Git

  1. Boas Práticas de Commit (Convenções de Commit)

  2. Estratégias de Branch (Estratégias de Branch)

  3. Workflows (Automação de Workflow)

Nível Avançado

  1. Git Internals (Git Internals: Como o Git Funciona por Dentro)

Recursos Adicionais

Referência Rápida

Ferramentas Recomendadas

Contribua!

Este é um projeto open source e suas contribuições são bem-vindas!

  • Encontrou um erro?

  • Tem uma sugestão?

  • Quer adicionar conteúdo?

Aprenda como contribuir (Contribuindo para o Git Pie 🤝)

Próximo Passo Recomendado: Comece pelos Conceitos Básicos (Conceitos Básicos do Git) para construir uma base sólida.

Intro - Aprenda sobre VCS

American pie
American pie

Nota do Autor

Olá pessoas, nesse texto irei falar sobre VCS (Sistema de Versionamento de Código, sigla em inglês) ou melhor, como o tema é mais conhecido - falarei sobre Git.

O que você vai aprender aqui?

Stifler teaching
Stifler teaching

"Deixa que o Stifler te explica essa parada!"

Nesse guia você vai aprender:

  • Como não perder código igual perdeu aquela crush do ensino médio

  • Como trabalhar em equipe sem querer matar seus colegas

  • Como versionar código igual um profissional (e não usando projeto-final-v3-agora-vai-mesmo.zip)

  • Como usar Git e não passar vergonha nas entrevistas de emprego

Roadmap de Aprendizado

American pie road
American pie road

A estrada do conhecimento é longa, mas é divertida!

Você está aqui!

Fundamentos de VCS

Git Básico

Workflow do Git

Branches e Merges

Git Remoto

Práticas Avançadas

Você virando um Git Master!

Mapa Mental dos Conceitos

Para você que gosta de ver o todo antes de se perder nos detalhes (tipo quando você olha o cardápio inteiro antes de pedir)

GitFundamentosComandos BásicosBranchesRemotoVersionamentoRepositóriosCommitsinitaddcommitstatusCriarMudarMesclarclonepushpull

Por que você deveria aprender Git?

Stifler convinced
Stifler convinced

"Confia no pai que essa é boa!"

Imagina só:

  • Você tá lá, codando tranquilo

  • Fez alterações MASSAS no projeto

  • Aí seu PC resolve dar aquela travada marota

  • E... BOOM! 💥 Perdeu tudo!

Ou pior:

  • Você e seu amigo precisam trabalhar no mesmo projeto

  • Vocês ficam trocando arquivo por WhatsApp

  • projeto_final.zip, projeto_final_v2.zip, projeto_final_v2_agora_vai.zip

  • No final ninguém sabe qual é a versão certa 🤦‍♂️

É aí que entra o Git! Ele é tipo aquele amigo que:

  • Guarda todas as versões do seu código

  • Deixa você voltar no tempo quando der m*rda

  • Permite que você e seus amigos trabalhem juntos sem criar caos

  • Te salva de passar vergonha em entrevistas de emprego

Pré-requisitos

Jim thinking
Jim thinking

"O que eu preciso saber antes de começar?"

  • Saber usar um terminal básico (tipo cd, ls, essas coisas)

  • Ter um editor de código (VSCode, Sublime, ou qualquer outro que você curta)

  • Vontade de aprender (e senso de humor para aguentar minhas piadas ruins)

Como usar este guia

Este material está organizado de forma progressiva:

  1. Começamos com o básico dos básicos

  2. Vamos evoluindo aos poucos

  3. No final você estará usando Git igual um profissional

Dica do Stifler: Não pule etapas! É tipo American Pie, você precisa ver o primeiro filme antes de entender as piadas do segundo!

Bora começar?

Lets do this
Lets do this

É hora de botar a mão na massa!

Escolha sua aventura:

Nota: Se em algum momento você se perder, não se preocupe! É normal, todo mundo já passou por isso. Até o Stifler já perdeu código antes de aprender Git!

Conceitos Básicos de Versionamento

Versionamento de Código

Versionamento é um conceito muito simples e usado no dia a dia de forma que nem percebemos. Por exemplo: Estamos em um projeto onde temos dois desenvolvedores:

  • Stifler

Stifler dude no
Stifler dude no
  • Jim

Jim american pie
Jim american pie

Esses dois desenvolvedores estão fazendo o "Milfs Go" uma especie revolucionaria e inovadora, além do tempo sendo um app para acharem a "milfs".

Aqui está uma milf para aqueles não habituados com o termo:

American pie good stuff
American pie good stuff

Controle de Versão

Versionamento é o ato de manipular versões, agora o Controle de Versão é um sistema que vai registrar as mudanças tanto num arquivo como em um projeto gigante ao longo do tempo.

Tipos de Controle de Versão

  1. Local

    • Mantém as versões apenas na sua máquina

    • Simples mas limitado

    • Exemplo: copiar e renomear arquivos

  2. Centralizado

    • Um servidor central guarda todas as versões

    • Todos se conectam a este servidor

    • Exemplo: SVN

  3. Distribuído

    • Cada desenvolvedor tem uma cópia completa

    • Trabalho offline possível

    • Exemplo: Git

Importância

Talvez agora você levante uma questão de o porque aprender "este trem" - como diria um amigo mineiro. Logo, a resposta é simples: esse tipo de ferramenta é essencial para o desenvolvimento já que nos entrega um poder de não somente trabalhar em conjunto de forma assíncrona e sem medo de acabar perdendo o que já foi feito.

Benefícios do Controle de Versão

  1. Histórico Completo

    • Rastreamento de todas as mudanças

    • Quem fez o quê e quando

    • Possibilidade de reverter alterações

  2. Trabalho em Equipe

    • Múltiplos desenvolvedores

    • Desenvolvimento paralelo

    • Resolução de conflitos

  3. Backup

    • Cópia segura do código

    • Recuperação de desastres

    • Múltiplas cópias distribuídas

Fluxo Básico

  1. Modificação

    • Alteração nos arquivos

    • Criação de novos arquivos

    • Exclusão de arquivos

  2. Stage

    • Preparação das mudanças

    • Seleção do que será versionado

    • Organização das alterações

  3. Commit

    • Confirmação das mudanças

    • Criação do ponto de versão

    • Registro no histórico

Boas Práticas

  1. Commits Frequentes

    • Mudanças pequenas e focadas

    • Mais fácil de entender e reverter

    • Melhor rastreabilidade

  2. Mensagens Claras

    • Descreva o que foi alterado

    • Seja conciso mas informativo

    • Use tempo verbal consistente

  3. Branches Organizados

    • Separe features em branches

    • Mantenha o main/master estável

    • Merge apenas código testado

Próximos Passos

Agora que você entende os conceitos básicos, está pronto para:

  • Aprender comandos específicos do Git

  • Entender branches e merges

  • Trabalhar com repositórios remotos

Próximo Capítulo: Git Básico (Conceitos Básicos do Git)

Dica: Mantenha este capítulo como referência! Os conceitos básicos são fundamentais para entender as operações mais avançadas que virão pela frente.

História do Controle de Versão

A Evolução do Versionamento

Como passamos de backups manuais para sistemas distribuídos modernos

1972SCCS (Source CodeControl System)Primeiro sistemareal de controle deversãoDesenvolvido paraIBM System/3701982RCS (RevisionControl System)Operações maisrápidasFormato de arquivomais eficiente1986PVCS (PolytronVersion ControlSystem)Primeiro sistemacomercial popular1990CVS (ConcurrentVersions System)Primeiro sistemacom suporte adesenvolvimentoparaleloRevolucionou odesenvolvimento emequipe2000SVN (Subversion)Sucessor espiritualdo CVSTracking dediretórios emetadataCommits atômicos2005Git & MercurialNascimento dossistemas distribuídosmodernosGit criado por LinusTorvaldsMercurial por MattMackall2008GitHub LaunchGit se tornamainstreamInício da era socialdo código2015Git dominaçãoTorna-se o padrãoda indústriaMais de 90% dosdesenvolvedoresusando GitHistória dos Sistemas de Controle de Versão

A Linha do Tempo Detalhada

Anos 70-80: A Pré-História do Código

SCCS (1972)

  • Criador: Marc Rochkind na Bell Labs

  • Inovações:

    • Primeiro sistema real de controle de versão

    • Introduziu o conceito de deltas reversos

    • Arquivos de histórico com extensão ,v

  • Limitações:

    • Apenas um arquivo por vez

    • Sem networking

    • Unix only

SCCS
|-- arquivo,v
|-- histórico
`-- locks

RCS (1982)

  • Criador: Walter F. Tichy

  • Melhorias:

    • Sistema de branching primitivo

    • Melhor performance

    • Formato de arquivo mais eficiente

    • Comandos mais intuitivos

  • Ainda usado para:

    • Controle de configuração

    • Documentação

    • Projetos simples

Anos 90: A Revolução Centralizada

CVS (1990)

  • Criador: Dick Grune

  • Revolucionou com:

    • Desenvolvimento paralelo

    • Operações em rede

    • Repositórios compartilhados

    • Tags e branches

  • Problemas famosos:

    • Commits não atômicos

    • Renomeação de arquivos complicada

    • Bugs de merge

CVS Server
    /    |    \
Client Client Client

SVN (2000)

  • Criador: CollabNet

  • Avanços:

    • Commits verdadeiramente atômicos

    • Melhor handling de binários

    • Renomeação e move de arquivos

    • Metadados versionados

  • Ainda popular em:

    • Empresas tradicionais

    • Projetos com muitos binários

    • Sistemas legados

Anos 2000+: A Era Distribuída

Git (2005)

  • Criador: Linus Torvalds

  • Motivação:

    • BitKeeper removeu licença gratuita do kernel Linux

    • Necessidade de sistema rápido e distribuído

  • Inovações:

    • Modelo distribuído

    • Branching super leve

    • Staging area

    • Integridade criptográfica

  • Por que dominou:

    • Performance excepcional

    • GitHub e social coding

    • Flexibilidade extrema

    • Workflow distribuído

Git Flow
main
 |\
 | feature
 |/
 |\
 | hotfix
 |/

Mercurial (2005)

  • Criador: Matt Mackall

  • Diferencias:

    • Interface mais amigável

    • Curva de aprendizado menor

    • Extensibilidade via Python

  • Usado por:

    • Facebook

    • Mozilla

    • Google (parcialmente)

Anos 2010+: A Era Social

GitHub (2008)

  • Transformou Git em plataforma social

  • Pull Requests revolucionaram code review

  • Actions trouxeram CI/CD integrado

  • Copilot iniciou era da IA no código

GitLab (2011)

  • Alternativa self-hosted ao GitHub

  • CI/CD integrado desde o início

  • DevOps como plataforma

Lições da História

O que Aprendemos

  1. Evolução Constante

    • De single-file para repositórios completos

    • De local para distribuído

    • De linha de comando para interfaces gráficas

  2. Padrões que Permaneceram

    • Importância do histórico

    • Necessidade de branches

    • Valor da colaboração

  3. Tendências Futuras

    • Integração com IA

    • Automação crescente

    • Colaboração em tempo real

Conclusão

A história dos sistemas de controle de versão é uma jornada fascinante de evolução tecnológica. De simples backups numerados até sistemas distribuídos com IA, cada era trouxe suas inovações e aprendizados. Como diria a mãe do Stifler: "As festas podem mudar, mas a diversão continua a mesma!"

E lembre-se: conhecer a história nos ajuda a entender melhor as ferramentas que usamos hoje e apreciar como chegamos até aqui. Afinal, se hoje podemos fazer um git push sem pensar duas vezes, é porque muita gente quebrou a cabeça com SCCS e CVS antes!

Tipos de Sistemas de Controle de Versão

Sistemas Locais

Imagine que o Stifler está tentando escrever a "bíblia das milfs" em seu computador. Toda vez que ele faz uma alteração importante, cria uma nova pasta chamada "versão_final", "versão_final_2", "versão_final_2_agora_vai"... Isso é basicamente um sistema local de controle de versão!

Características dos Sistemas Locais

  • Simplicidade: Tão simples quanto renomear arquivos

  • Independência: Funciona offline, como o Stifler escrevendo sozinho em casa

  • Limitações: Se o HD queimar, tchau bíblia das milfs

  • Risco: Um problema no computador e todo o histórico se perde

Version control system sistema local
Version control system sistema local
Diagrama de um sistema local (ou como Stifler organiza seus arquivos)

Analogia da Festa

É como fazer uma festa sozinho. Você tem todo o controle, mas:

  • Ninguém mais participa

  • Se sua casa pegar fogo, acabou a festa

  • Você não pode estar em dois lugares ao mesmo tempo

Sistemas Centralizados

Agora imagine que Jim e Stifler decidem trabalhar juntos no "Milfs Go". Eles precisam de um lugar central para guardar o código - tipo a casa da mãe do Stifler (que ironicamente é uma milf).

Como Funciona

  • Um servidor central (a casa da mãe do Stifler)

  • Todos os desenvolvedores se conectam a ele

  • Precisa de internet para trabalhar

Desvantagens dos Sistemas Centralizados

  • Ponto único de falha: Se a mãe do Stifler sair de casa, ninguém trabalha

  • Dependência de rede: Sem internet, sem código

  • Performance: Lento como Stifler tentando resolver cálculo

  • Conflitos: Como Jim e Stifler brigando pelo mesmo arquivo

Version control system sistema compartilhado
Version control system sistema compartilhado
Diagrama de um sistema centralizado (ou a casa da mãe do Stifler)

Analogia da Festa Centralizada

É como uma festa na casa da mãe do Stifler:

  • Todo mundo precisa ir até lá

  • Se a casa fechar, acabou a festa

  • Só dá para fazer as coisas se você estiver lá

Sistemas Distribuídos

Finalmente, temos o sistema que é tipo a internet das milfs - todo mundo tem uma cópia completa de tudo!

Por que é Melhor?

  • Trabalho offline: Como Stifler "estudando" em casa

  • Backup distribuído: Cada cópia é um backup completo

  • Performance: Rápido como Stifler correndo atrás de... você sabe

  • Flexibilidade: Múltiplos fluxos de trabalho possíveis

Analogia da Festa Distribuída

É como ter várias festas simultâneas:

  • Cada um pode ter sua própria festa

  • As festas podem se sincronizar

  • Se uma festa acabar, as outras continuam

Características Avançadas

  1. Branches Distribuídos

    • Como diferentes capítulos do "Milfs Go"

    • Cada um trabalha no seu

    • Depois junta tudo

  2. Colaboração

    • Pull requests (como pedir permissão para a mãe do Stifler)

    • Code review (Jim revisando as besteiras do Stifler)

    • Forks (fazer sua própria versão do "Milfs Go")

Tabela Comparativa Estilo American Pie

Característica

Local

Centralizado

Distribuído

Backup

Frágil como o ego do Stifler

Médio

Forte como a mãe do Stifler

Colaboração

Solo

Limitada

Total

Offline

Sim

Não

Sim

Complexidade

Fácil

Média

Complexa

Confiabilidade

Baixa

Média

Alta

Exemplos Históricos

Sistemas Locais (Anos 80)

  • RCS: O vovô dos sistemas de versão

  • SCCS: Ainda mais velho que a mãe do Stifler

Sistemas Centralizados (Anos 90-2000)

  • SVN: O pai dos sistemas centralizados

  • CVS: O tio que ninguém mais visita

  • Perforce: O primo rico

Sistemas Distribuídos (2005+)

  • Git: O rei da festa

  • Mercurial: O amigo legal que ninguém lembra

  • Bazaar: Aquele que tentou mas não vingou

Conclusão

Escolher um sistema de controle de versão é como escolher onde fazer a festa:

  • Na sua casa (Local)

  • Na casa da mãe do Stifler (Centralizado)

  • Em todas as casas ao mesmo tempo (Distribuído)

Stifler aprovando sistemas distribuídos

Nota Final

Lembre-se: assim como Stifler aprendeu a respeitar as milfs, você precisa respeitar seu sistema de controle de versão. Escolha sabiamente!

E viveram felizes para sempre com Git

Sistemas de Controle de Versão Local

Um sistema de controle de versão local é a primeira e mais básica forma de versionamento de código. Imagine como uma máquina do tempo pessoal para seu código, onde todas as mudanças são registradas e armazenadas localmente no seu computador.

Como Funciona na Prática

Unsupported markdown: list
Unsupported markdown: list
Unsupported markdown: list
Unsupported markdown: list

Seus Arquivos

Arquivos Modificados

Base de Dados Local

Histórico de Versões

Analogia com um Álbum de Fotos

+------------------------+
|     Seu Projeto       |
|  +-----------------+  |
|  | Versão Atual    |  |
|  +-----------------+  |
|  | Versão Anterior |  |
|  +-----------------+  |
|  | Versões Antigas |  |
|  +-----------------+  |
+------------------------+

Componentes Principais

1. Base de Dados Local

  • Armazena todas as mudanças

  • Mantém metadados (autor, data, descrição)

  • Gerencia diferentes versões

  • Organiza o histórico completo

2. Sistema de Tracking

Delta V1

Delta V2

Delta V3

Arquivo Original

Versão 1

Versão 2

Versão 3

3. Mecanismo de Snapshots

Tempo ------>

V1  [Snapshot 1]
    |
V2  [Snapshot 2]
    |
V3  [Snapshot 3]
    |
V4  [Snapshot 4]

Cenários de Uso

1. Desenvolvimento Solo

BackupLocalDevBackupLocalDevDesenvolve featureSalva versãoBackup periódicoReverte se necessário

2. Projetos Pessoais

+-------------------+
| Projeto Pessoal   |
|                   |
| + Código         |
| + Documentação   |
| + Recursos      |
| + Configurações |
+-------------------+
      |
      v
+-------------------+
| Sistema Local VCS |
+-------------------+

Processo de Versionamento

1. Criação de Versões

Adiciona

Commit

Nova mudança

Modificado

Staged

Commitado

2. Recuperação de Versões

HEAD (Versão Atual)
    |
    v
[V3] --> [V2] --> [V1]
    ^
    |
  Checkout

Vantagens Detalhadas

1. Simplicidade

  • Fácil de configurar

  • Sem dependências externas

  • Interface simples

  • Aprendizado rápido

2. Performance

Local

Operação

Resultado

3. Autonomia

  • Trabalho offline

  • Controle total

  • Independência de rede

  • Decisões imediatas

Limitações Detalhadas

1. Riscos de Perda

2. Colaboração Limitada

Desenvolvedor 1     Desenvolvedor 2
     |                   |
  Versão A            Versão B
     |                   |
     X------------------X
     |                   |
Impossível Sincronizar

Ferramentas Populares

1. RCS (Revision Control System)

check-out

check-in

retrieve

Arquivo

Workspace

RCS Database

2. SCCS (Source Code Control System)

+------------------+
| SCCS Structure   |
|                  |
| s.file1          |
| s.file2          |
| s.file3          |
+------------------+

Melhores Práticas

1. Organização

Organiza

Versiona

Documenta

Projeto

Módulos

Componentes

Histórico

2. Backup Regular

+----------------+
| Projeto Local  |
+----------------+
        |
        v
+----------------+
| Backup Externo |
+----------------+
        |
        v
+----------------+
| Cloud Storage  |
+----------------+

3. Documentação

  • Comentários claros

  • Descrições de versão

  • Registro de mudanças

  • Notas de implementação

Sistemas de Controle de Versão Centralizado

Um sistema de controle de versão centralizado (CVCS) é como uma festa na casa da mãe do Stifler - todos precisam ir ao mesmo lugar para participar! Este sistema utiliza um servidor central que armazena todos os arquivos versionados e permite que múltiplos desenvolvedores colaborem no mesmo projeto.

Características Principais

1. Servidor Central

  • Repositório único e autoritativo

  • Controle de acesso centralizado

  • Backup centralizado

  • Administração simplificada

2. Clientes

  • Checkout de arquivos específicos

  • Histórico parcial

  • Dependência de conectividade

  • Workspace local limitado

A Casa da Mãe do Stifler

Como uma festa na casa da mãe do Stifler, todos precisam ir ao mesmo lugar para participar!

Arquitetura

Servidor Central

Cliente 1

Cliente 2

Cliente 3

Cliente N

Estrutura do Sistema

+----------------+
      |    Servidor    |
      |    Central     |
      +----------------+
            ||||
    +-------++-+-------+
    |        |         |
+-------+ +-------+ +-------+
|Cliente| |Cliente| |Cliente|
|   1   | |   2   | |   3   |
+-------+ +-------+ +-------+

Fluxo de Operações

ServidorLocalDevServidorLocalDevCheckoutUpdateModificaCommitConfirma

Vantagens e Desvantagens

Vantagens

  1. Controle Centralizado

    • Governança simplificada

    • Políticas uniformes

    • Backup único

    • Auditoria facilitada

  2. Administração Simples

    • Gerenciamento de usuários

    • Controle de permissões

    • Monitoramento de uso

    • Manutenção única

  3. Visibilidade do Projeto

    • Visão única do projeto

    • Status em tempo real

    • Progresso transparente

    • Colaboração sincronizada

Desvantagens

  1. Ponto Único de Falha

Impacto

Resultado

Consequência

Servidor Down

Sem Acesso

Time Parado

Perda de Produtividade

  1. Dependência de Rede

Servidor
    ^
    |
    X (Conexão Perdida)
    |
Cliente
  1. Performance Limitada

Rede

Latência

Operação

Servidor

Resposta

Exemplos Famosos

VCS CentralizadoSVNCVSPerforceApacheMultiplataformaConfiávelLegadoUnixHistóricoEmpresarialEscalávelProprietário

Casos de Uso Ideais

1. Equipes Localizadas

+----------------+
|   Escritório   |
|  +----------+  |
|  | Time Dev |  |
|  +----------+  |
+----------------+
        |
   Servidor VCS

2. Projetos com Ativos Grandes

Centralizado

Checkout Parcial

Checkout Parcial

Arquivos Grandes

Servidor

Cliente 1

Cliente 2

3. Controle Rigoroso

AdminServidorDevAdminServidorDevSolicita AcessoNotificaAprovaConcede Acesso

Melhores Práticas

1. Backup Regular

Servidor Principal
      |
      v
Backup Diário
      |
      v
Backup Offsite

2. Monitoramento

Monitora

Monitora

Monitora

Sistema

Performance

Disponibilidade

Segurança

3. Políticas de Acesso

Autenticação

Leitura

Escrita

Admin

Usuário

Permissões

Código

Commits

Configurações

Ferramentas de Suporte

1. Integração Contínua

+----------------+
| Build Server   |
|  +----------+  |
|  | CI/CD    |  |
|  +----------+  |
+----------------+

2. Code Review

ServidorReviewerDevServidorReviewerDevCommitNotificaAprova/Rejeita

3. Rastreamento de Issues

+----------------+
| Issue Tracker  |
|  #123 Bug     |
|  #124 Feature |
|  #125 Task    |
+----------------+

Sistemas de Controle de Versão Distribuído

A Rede Social das Milfs

Sabe aquela rede social onde todo mundo tem sua própria cópia das fotos e vídeos? Pois é, um sistema distribuído é exatamente assim! Cada desenvolvedor tem uma cópia completa do projeto, como se cada um tivesse sua própria festa particular.

Por que é tipo uma Rede Social?

Todo Mundo tem Tudo

Imagine que o Stifler, o Jim e o Finch estão trabalhando juntos. Cada um tem uma cópia completa do projeto no seu computador. É como se cada um tivesse baixado todas as fotos e vídeos da festa - ninguém depende do celular dos outros pra ter acesso às memórias da noitada.

Trabalho Offline? Pode Sim!

Diferente do sistema centralizado (onde todo mundo depende da casa da mãe do Stifler), aqui cada um pode trabalhar no seu canto. O Jim pode codar mesmo quando sua internet cair, o Finch pode fazer alterações no ônibus, e o Stifler... bem, ele pode programar onde ele quiser (provavelmente enquanto procura milfs no Tinder).

Compartilhando as Novidades

Quando alguém quer mostrar seu trabalho, é só dar um "push" (tipo postar na rede social). E quando quer ver o que os outros fizeram? Dá um "pull" (como dar aquela stalkeada básica no feed dos amigos).

Conceito Básico

Repo Central

Dev 1

Dev 2

Dev 3

Estrutura Distribuída

+----------------+
    |  Repositório   |
    |    Remoto      |
    +----------------+
     /      |       \
+-------+ +-----+ +-------+
| Clone | |Clone| | Clone |
|   1   | |  2  | |   3   |
+-------+ +-----+ +-------+

Fluxo de Trabalho

Other DevRemoteLocalOther DevRemoteLocalPushPullPushPull

Características Principais

1. Independência Total

  • Trabalho offline como um campeão

  • Commits locais sem depender de ninguém

  • Sua festa, suas regras

2. Backup Distribuído

Clone

Clone

Clone

Backup

Backup

Backup

Repo Central

Dev 1

Dev 2

Dev 3

3. Performance Aprimorada

Local Operations
    ⚡️ SUPER RÁPIDO ⚡️
    └── Commits
    └── Branches
    └── History
    └── Diffs

Vantagens de Ter Sua Própria Festa

1. Independência Total

  • Faça commits sem precisar de internet

  • Crie branches experimentais sem medo

  • Trabalhe no seu ritmo

  • Teste coisas malucas sem ninguém saber

2. Backup em Todo Lugar

Lembra quando o Stifler perdeu todas as fotos da festa porque derrubou cerveja no computador? Com DVCS isso não seria um problema! Como todo mundo tem uma cópia completa, é praticamente impossível perder o código. É tipo ter backup até no backup do backup.

3. Performance Insana

Quase tudo é local, então é mais rápido que o Stifler correndo atrás de uma milf. Commits, branches, histórico - tudo acontece na velocidade da luz porque não precisa ficar perguntando pro servidor.

Como Funciona na Prática?

O Dia a Dia

  1. Clone: Primeiro você clona o repositório - é tipo fazer o download da festa inteira

  2. Trabalho Local: Faz suas alterações na sua cópia - como editar suas fotos antes de postar

  3. Commit: Salva as alterações localmente - guardando suas edições no rascunho

  4. Push: Envia para o repositório remoto - finalmente postando na rede social

  5. Pull: Baixa alterações dos outros - atualizando seu feed

Quando Tem Treta

Às vezes duas pessoas mudam a mesma coisa - tipo o Stifler e o Jim editando a mesma foto. Isso gera um conflito, mas não é o fim do mundo:

  1. O sistema avisa que tem conflito

  2. Você decide qual versão manter (ou combina as duas)

  3. Faz um novo commit com a resolução

  4. Todo mundo fica feliz!

1. Flexibilidade Máxima

FlexibilidadeTrabalho OfflineMúltiplos RemotesFluxos CustomizadosCommits LocaisBranches LocaisGitHubGitLabBitbucketFeature BranchesGitflowTrunk Based

2. Colaboração Avançada

3. Segurança Reforçada

+-------------------+
|   Repo Central    |
+-------------------+
        |||
   +----------+
   | Clones   |
   +----------+
   | Backups  |
   +----------+
   | História |
   +----------+

Sistemas Populares

DVCSGitMercurialGitHubGitLabBitbucketFacebookMozilla

Workflows Populares

1. Feature Branch

Cada nova funcionalidade ganha sua própria branch. É como se cada nova ideia maluca do Stifler tivesse seu próprio espaço para não bagunçar a festa principal.

ReviewFeatureMainReviewFeatureMainBranchCommitsPull RequestMerge

2. Gitflow

Um workflow mais estruturado, com branches específicas para desenvolvimento, features, releases e hotfixes. É tipo ter áreas VIP, pista de dança e bar separados na festa.

Master

Develop

Feature 1

Feature 2

Hotfix

Release

3. Trunk Based

Desenvolvimento direto na main com branches curtas. É como uma festa mais intimista, onde todo mundo fica no mesmo ambiente.

main
 |
 ├── feature/quick
 |     └── merge rápido
 |
 ├── feature/small
 |     └── merge rápido
 |
 └── atual

Melhores Práticas

1. Commits Atômicos

  • Faça commits pequenos e focados

  • Escreva mensagens que façam sentido

  • Não commita código quebrado

  • Imagine que você vai ler isso bêbado depois

Commit

Commit

Commit

Pequeno

Focado

Testado

Documentado

2. Branches Organizados

  • Crie uma branch pra cada feature nova

  • Mantenha a main/master sempre funcionando

  • Não tenha medo de experimentar em branches

  • Merge só quando tiver certeza

main
 ├── feature/
 │    ├── nova-festa
 │    └── mais-milfs
 ├── hotfix/
 │    └── bug-critico
 └── release/
      └── v2.0

3. Sincronização Regular

  • Dê pull antes de começar a trabalhar

  • Push quando terminar algo importante

  • Mantenha seu código atualizado

  • Não deixe commits acumularem

RemoteLocalRemoteLocalCommitCommitPushPull

Ferramentas Essenciais

1. Interfaces Gráficas

  • GitKraken

  • SourceTree

  • GitHub Desktop

2. Extensões IDE

+---------------+
| IDE           |
|  +----------+ |
|  | Git      | |
|  | Tools    | |
|  +----------+ |
+---------------+

Toda IDE que se preze tem integração com Git. Use e abuse delas!

3. CLI Aprimorada

Personalize seu terminal para trabalhar melhor com Git. Aliases e prompts podem salvar seu dia!

Git

Git

Git

oh-my-zsh

Aliases

Prompts

Completions

Conclusão

DVCS é como ter uma festa particular que pode se conectar com outras festas quando quiser. Cada um tem seu espaço, suas regras, mas todo mundo pode compartilhar quando estiver pronto! É a democracia do código - todo mundo tem poder igual, ninguém depende de um servidor central, e a festa nunca para!

Sync

Sync

Sync

Sua Festa

Festa Central

Festa do Jim

Festa do Stifler

Comparando Sistemas de Controle de Versão

Vamos fazer uma análise profunda dos diferentes sistemas de controle de versão, usando analogias divertidas para entender melhor cada um. É como comparar diferentes tipos de festas - cada uma tem seu propósito e seu público!

Sistemas Locais: A Festa Caseira

+------------------+
|    Seu PC        |
|  +-----------+   |
|  | Projeto   |   |
|  | v1.txt    |   |
|  | v2.txt    |   |
|  | final.txt |   |
|  +-----------+   |
+------------------+

Vantagens

  • Rápido como Flash - tudo acontece no seu PC

  • Simples de usar - é só copiar e colar

  • Funciona offline - não precisa de internet

Desvantagens

  • Zero colaboração - é festa solo

  • Sem backup - se o PC morrer, adeus código

  • Organização manual - você precisa gerenciar tudo

Quando Usar

  • Projetos pessoais pequenos

  • Aprendizado inicial

  • Quando você é tipo o Stifler trabalhando sozinho

Sistemas Centralizados: A Festa na Casa da Mãe do Stifler

+---------------+
  |   Servidor    |
  |   Central     |
  +---------------+
       /|\
      / | \
     /  |  \
PC1  PC2  PC3
Dev  Dev  Dev

Vantagens

  • Controle central - todo mundo sabe onde está o código

  • Mais organizado - versões numeradas certinhas

  • Permissões claras - você decide quem pode fazer o quê

Desvantagens

Servidor
    ^
    |
    X (Conexão Perdida)
    |
Cliente
   :(
  • Precisa de internet - sem conexão, sem festa

  • Servidor único - se cair, todo mundo chora

  • Branches pesados - criar branches é como organizar outra festa

Quando Usar

  • Equipes pequenas e médias

  • Projetos que precisam de controle rígido

  • Quando você quer saber exatamente quem fez o quê

Sistemas Distribuídos: O Festival de Código

+----------------+
    |  Repositório   |
    |    Central     |
    +----------------+
     /      |       \
+-------+ +-----+ +-------+
| Clone | |Clone| | Clone |
|   1   | |  2  | |   3   |
+-------+ +-----+ +-------+
   Jim    Stifler  Finch

Vantagens

  • Todo mundo tem uma cópia - a festa está em todo lugar

  • Trabalho offline - faça código até no busão

  • Branches leves - crie quantas quiser

  • Backup natural - cada clone é um backup

Desvantagens

Branch    Branch
  \         /
   \       /
    \     /
  Conflito!
     |
 Resolução
     |
   Merge
  • Curva de aprendizado - tem muito comando pra aprender

  • Complexidade - às vezes é difícil saber o que está acontecendo

  • Conflitos mais frequentes - quando todo mundo mexe em tudo

Quando Usar

  • Projetos grandes

  • Equipes distribuídas

  • Código open source

  • Quando você quer a flexibilidade máxima

Tabela Comparativa Completa

Característica

Local

Centralizado

Distribuído

Velocidade

Muito Rápida

Depende da Rede

Rápida

Colaboração

Impossível

Limitada

Ilimitada

Backup

Nenhum

Único

Múltiplos

Complexidade

Simples

Média

Alta

Offline

Sempre

Nunca

Sempre

Aprendizado

Fácil

Médio

Difícil

Conflitos

Nenhum

Comuns

Gerenciáveis

Escolhendo Seu Sistema

+-------------------+
|    Sua Escolha    |
+-------------------+
        |
   +----+----+
   |         |
Local    Centralizado
   |         |
   +----+----+
        |
   Distribuído

Para Iniciantes

Se você está começando, comece com um sistema local. É como aprender a fazer festa no seu quarto antes de ir pra balada.

Para Times Pequenos

Um sistema centralizado pode ser perfeito. Todo mundo sabe onde é a festa (o servidor) e as regras são claras.

Para Projetos Grandes

Sistema distribuído é o caminho. É como ter várias festas interligadas, cada uma com sua própria dinâmica.

Conclusão

+-------------+  +-------------+  +-------------+
|   Local     |  |Centralizado |  |Distribuído  |
| Festa Solo  |  |   Festa     |  |  Festival   |
|             |  |  na Casa    |  |    Open     |
|   \o/       |  |    \o/\o/   |  | \o/\o/\o/  |
+-------------+  +-------------+  +-------------+

Não existe sistema perfeito - existe o sistema certo para cada situação. É como escolher entre:

  • Uma festa íntima em casa (Local)

  • Uma festa organizada na casa da mãe do Stifler (Centralizado)

  • Um mega festival com várias stages (Distribuído)

A escolha depende do seu projeto, equipe e necessidades. E lembre-se: o importante é o código (ou a festa) fluir bem!

Controle de Versão Moderno

A Festa Continua!

Tendências Atuais

  1. Integração com Cloud

    • GitHub/GitLab/Bitbucket

    • Como festas online

    • Sempre disponível

  2. CI/CD Integration

    • Automação de testes

    • Deploy automático

    • Festa sem trabalho manual

  3. Ferramentas Gráficas

    • GitKraken

    • SourceTree

    • Interface amigável

O Futuro

  1. IA e Machine Learning

    • Resolução automática de conflitos

    • Sugestões de código

    • Como ter um DJ automático

  2. Blockchain

    • Versionamento descentralizado

    • Imutabilidade

    • A próxima revolução?

Melhores Práticas Modernas

  1. Trunk-Based Development

    • Integração contínua

    • Deploys frequentes

    • Festa sem fim

  2. Feature Flags

    • Controle de funcionalidades

    • Testes em produção

    • Como VIP da festa

Controle de Versão Híbrido

O controle de versão híbrido combina características de diferentes sistemas de versionamento para criar soluções mais flexíveis e adaptáveis.

Conceitos Básicos

O que é Controle de Versão Híbrido?

Sistema Híbrido

Centralizado

Distribuído

Cloud

Controle

Flexibilidade

Acessibilidade

Características Principais

  • Flexibilidade: Combina múltiplos modelos

  • Adaptabilidade: Ajusta-se às necessidades

  • Escalabilidade: Cresce com o projeto

  • Compatibilidade: Integra diferentes sistemas

Modelos Comuns

Git + Servidor Central

Push

Pull

Backup

CI/CD

Git Local

Servidor Central

Git Local 2

Storage

Pipeline

Monorepo Híbrido

Monorepo

Git

SVN

Módulos Novos

Código Legacy

Vantagens e Desvantagens

Vantagens

  1. Flexibilidade Máxima

    • Adapta-se a diferentes equipes

    • Suporta múltiplos workflows

    • Integra sistemas legados

  2. Melhor Controle

    • Governança centralizada

    • Liberdade local

    • Backup redundante

  3. Transição Suave

    • Migração gradual

    • Menor resistência

    • Aprendizado progressivo

Desvantagens

DesafiosComplexidadeOverheadCustoSetupManutençãoTreinamentoSincronizaçãoBackupIntegraçãoInfraestruturaFerramentasSuporte

Implementações Práticas

Modelo Git + SVN

SVNBridgeGitDevSVNBridgeGitDevCommit localSyncConvert & CommitUpdateSync back

Exemplo de Configuração

# Git com SVN remote
git svn clone https://svn.example.com/repo
git svn fetch
git svn rebase
git svn dcommit

# Git com múltiplos remotes
git remote add github https://github.com/user/repo
git remote add gitlab https://gitlab.com/user/repo

Melhores Práticas

1. Planejamento

  • Defina claramente os objetivos

  • Mapeie os sistemas existentes

  • Estabeleça políticas de uso

2. Implementação

Análise

Piloto

Migração Gradual

Treinamento

Expansão

3. Manutenção

  • Monitore performance

  • Atualize bridges/conectores

  • Mantenha documentação

Ferramentas e Integrações

Populares

  • git-svn: Bridge Git-SVN

  • SubGit: Migração e sincronização

  • GitLab: Suporte multi-repo

Automação

Trigger

Build

Test

Deploy

Commit

CI/CD

Artifacts

Quality

Production

Casos de Uso

Enterprise

  • Sistemas legados + modernos

  • Múltiplas equipes

  • Requisitos de compliance

Startups

  • Rápida iteração

  • Flexibilidade máxima

  • Integração cloud

Futuro do Versionamento Híbrido

Tendências

FuturoCloudIADevOpsMulti-cloudServerlessAuto-syncConflict ResolutionPipeline IntegrationAuto-deployment

Inovações Esperadas

  • Sincronização inteligente

  • Resolução automática de conflitos

  • Integração com blockchain

  • Análise preditiva de código

Recursos Adicionais

Documentação

Comunidade

  • Fóruns de discussão

  • Grupos de usuários

  • Conferências técnicas

Dica Pro: Comece pequeno, com um projeto piloto, antes de expandir para toda a organização!

Controle de Versão Baseado em Blockchain

O controle de versão baseado em blockchain é uma abordagem inovadora que combina os princípios de sistemas de controle de versão distribuídos com a tecnologia blockchain.

Conceitos Fundamentais

O que é Controle de Versão Blockchain?

Hash

Chain

Consenso

Commit

Bloco

Histórico Imutável

Validação

Características Principais

  • Imutabilidade: Histórico permanente e inalterável

  • Descentralização: Sem servidor central

  • Transparência: Todas as alterações são rastreáveis

  • Criptografia: Segurança integrada

  • Consenso: Validação distribuída de alterações

Implementações

GitChain

Hash

Smart Contract

Consenso

Confirmação

Commit Local

Bloco

Rede Blockchain

Validação

Histórico Global

Características do GitChain

  • Integração com Git existente

  • Smart contracts para validação

  • Tokens para governança

  • Prova de trabalho otimizada

Vantagens e Desvantagens

Vantagens

  • Histórico imutável

  • Auditoria garantida

  • Descentralização real

  • Propriedade verificável

  • Segurança criptográfica

Desvantagens

DesafiosDesempenhoComplexidadeCustoLatênciaConsumoSetupManutençãoInfraestruturaOperação

Casos de Uso

Ideal Para

  • Software crítico

  • Contratos inteligentes

  • Projetos regulamentados

  • Propriedade intelectual

  • Auditorias rigorosas

Exemplos Práticos

Commit

Validação

Token

Hash

Código Fonte

Smart Contract

Blockchain

Propriedade

Auditoria

Ferramentas e Plataformas

Populares

  • CodeChain: Plataforma blockchain para código

  • VersionX: Sistema híbrido Git+Blockchain

  • BlockVCS: Controle de versão descentralizado

Integração

# Exemplo de uso com CodeChain
cchain init
cchain commit -m "feat: nova funcionalidade"
cchain validate
cchain push --network ethereum

Melhores Práticas

Recomendações

  1. Use redes privadas para testes

  2. Implemente validação em múltiplas camadas

  3. Mantenha backups locais

  4. Monitore custos de transação

  5. Planeje a governança

Workflow Sugerido

NetworkChainLocalDevNetworkChainLocalDevCommitValidateConsensusConfirmation

Futuro e Tendências

Desenvolvimentos

  • Integração com CI/CD

  • Redes específicas para código

  • Otimização de recursos

  • Governança automatizada

Inovações Esperadas

FuturoAutomaçãoEscalabilidadeIntegraçãoCI/CDValidaçãoShardingL2IDEsCloud

Recursos Adicionais

Documentação

Comunidade

  • Fóruns de discussão

  • Grupos de desenvolvedores

  • Conferências especializadas

Dica Pro: Comece com uma rede privada para experimentar antes de migrar para uma rede pública!

Fluxos de Trabalho em Versionamento

Modelos de Fluxo de Trabalho

Trunk-Based Development

  • Desenvolvimento direto na branch principal

  • Integração contínua frequente

  • Ideal para equipes pequenas e ágeis

Feature Branch Workflow

  • Branch separada para cada feature

  • Merge através de pull requests

  • Revisão de código facilitada

Gitflow

  • Branches específicas para features, releases e hotfixes

  • Estrutura mais rigorosa

  • Ideal para releases planejadas

Forking Workflow

  • Fork do repositório principal

  • Comum em projetos open source

  • Maior isolamento entre contribuições

Escolhendo um Workflow

Fatores a Considerar

  • Tamanho da equipe

  • Frequência de releases

  • Complexidade do projeto

  • Necessidades de QA

Exemplos Práticos

Feature Branch

Code Review

Testes

Merge para Main

Deploy

Boas Práticas

  1. Commits frequentes e pequenos

  2. Mensagens de commit claras

  3. Code review regular

  4. Testes antes do merge

  5. Documentação atualizada

Ferramentas de Suporte

  • CI/CD pipelines

  • Code review platforms

  • Issue trackers

  • Automação de testes

Trunk-Based Development

Imagine uma festa onde todo mundo dança na mesma pista. É assim que funciona o Trunk-Based Development (TBD)!

Anatomia do TBD

mainfeature1feature20-f8646461-217fcf52-6e761dd4-d5ba91f5-25eae657-e501b4f

Como Funciona?

Todo mundo trabalha direto na branch principal (trunk/main):

Deploy

Commit

Commit

Commit

Main/Trunk

Produção

Dev 1

Dev 2

Dev 3

Regras do Jogo

1. Commits Pequenos e Frequentes

mainfeature0-026b238pequeno-1pequeno-2pequeno-3

2. Testes Antes de Tudo

3. Feature Flags

  • Código novo entra escondido

  • Ativa quando estiver pronto

  • Como uma surpresa na festa!

Ciclo de Vida do Código

maindesenvolvimentoiniciocodigotestesreviewdeploy

Fluxo de Trabalho Típico

mainfeature-flaghotfix0-86ab403add-flagdev-1dev-2fixrelease

Por Que Usar?

Vantagens

  • Integração contínua real

  • Menos conflitos

  • Deploy mais rápido

  • Todo mundo no mesmo ritmo

Desafios

  • Precisa de muita disciplina

  • Testes automatizados são obrigatórios

  • Feature flags para código incompleto

Na Prática

Fluxo Básico

1. Código novo
2. Testes locais
3. Code review
4. Merge na main
5. Deploy

Dicas de Sobrevivência

  • Commits pequenos

  • Testes, testes e mais testes

  • Feature flags são seus amigos

  • Code review rápido

Conclusão

TBD é rápido, moderno e eficiente. Como uma festa bem organizada, todo mundo se diverte junto, mas seguindo algumas regras básicas para manter tudo funcionando!

Feature Branch Workflow

Imagine que cada nova funcionalidade é como uma nova cena do American Pie - precisa ser filmada separadamente antes de entrar no filme final!

Como Funciona?

mainfeature/loginfeature/perfil0-c8c5ecd1-e2d07c42-2cc84963-36d079c4-3123e455-9b21eb07-bc16b81

Regras do Jogo

1. Uma Branch por Feature

Main

feature/login

feature/perfil

feature/chat

Pull Request

2. Processo de Review

MainReviewerDevMainReviewerDevCria BranchDesenvolvePull RequestCode ReviewFeedbackAjustesAprova & Merge

Anatomia de uma Feature Branch

main
  │
  ├── feature/login
  │   ├── commit: "Adiciona form"
  │   ├── commit: "Valida campos"
  │   └── commit: "Integra API"
  │
  ├── feature/perfil
  │   ├── commit: "Layout base"
  │   └── commit: "Upload foto"
  │
  └── feature/chat
      └── commit: "MVP chat"

Fluxo de Trabalho

1. Iniciando uma Feature

git checkout -b feature/nova-funcionalidade

2. Desenvolvimento

3. Mantendo Atualizado

MainFeature BranchMainFeature Branchgit pull origin mainAtualiza BranchResolve Conflitos

Boas Práticas

1. Nomes de Branches

✅ feature/adiciona-login
✅ feature/perfil-usuario
✅ feature/chat-tempo-real

❌ feature/f1
❌ nova-coisa
❌ mudancas-jim

2. Commits Organizados

mainfeature/login0-ead22fefeat: form basefeat: validaçãotest: casos loginfix: feedback erro

Pull Requests

Estrutura Ideal

📝 Pull Request: Adiciona Sistema de Login

✨ O que foi feito:
- Form de login responsivo
- Validação de campos
- Integração com API
- Testes unitários

🔍 Como testar:
1. Checkout na branch
2. npm install
3. npm run test
4. Teste manual do form

📸 Screenshots:
[imagens do antes/depois]

Resolução de Conflitos

Simples

Complexo

Conflito Detectado

Tipo?

Resolve Local

Consulta Time

Testa

Commit Resolution

Dicas de Sobrevivência

1. Mantenha as Features Pequenas

Grande Feature ❌
├── 2 semanas
├── 50 arquivos
└── Difícil review

Features Menores ✅
├── 2-3 dias
├── 5-10 arquivos
└── Review tranquilo

2. Review Checklist

Code ReviewFuncionalidadeQualidadeTestesDocumentaçãoRequisitos OKCasos de UsoClean CodePerformanceUnitáriosIntegraçãoComentáriosREADME

Métricas de Sucesso

📊 Indicadores Saudáveis

Tempo de Branch     ┌────────────┐
2-3 dias           |██████░░░░░░| ✅

Tamanho do PR      ┌────────────┐
200-400 linhas     |████░░░░░░░░| ✅

Taxa de Aprovação  ┌────────────┐
Primeira review    |████████░░░░| ✅

Conclusão

Feature Branch Workflow é como dirigir na sua própria pista: você tem liberdade para desenvolver no seu ritmo, mas sempre seguindo as regras de trânsito para chegar seguro ao destino!

Feature BranchIsolamentoQualidadeColaboraçãoDesenvolvimento SeguroExperimentosCode ReviewTestesFeedbackConhecimento

Gitflow Workflow

Se o Feature Branch é uma festa na casa do Stifler, o Gitflow é o baile de formatura - tem regras, tem estrutura, mas ainda é divertido!

Estrutura Principal

maindevelopfeature/loginrelease/1.00-d803c7e1-7050f912-0bbc12b3-f5fb2945-f8c98af

Branches Principais

1. Main e Develop

Sempre estável

Próxima versão

Release pronta

main

Produção

develop

Desenvolvimento

2. Branches de Suporte

GitflowFeatureReleaseHotfixNova funcionalidadeSai de developMerge em developPreparaçãoBugfixMerge em main/developCorreção urgenteSai de mainMerge em main/develop

Ciclo de Vida

1. Feature Development

2. Preparação de Release

maindeveloprelease/1.00-67a668e1-7eee0d5bump versionfix bugs

3. Hotfix em Produção

Fluxo de Trabalho Completo

feature start

feature finish

release start

release finish

release finish

hotfix start

hotfix finish

hotfix finish

develop

feature/nova

release/1.0

main

hotfix/bug

Boas Práticas

1. Nomenclatura

Features:
  feature/login
  feature/user-profile

Releases:
  release/1.0.0
  release/2.1.0

Hotfixes:
  hotfix/security-fix
  hotfix/crash-bug

2. Versionamento

VersãoMajorMinorPatchBreaking Changes1.0.0 -> 2.0.0Novas Features1.0.0 -> 1.1.0Bugfixes1.0.0 -> 1.0.1

Quando Usar Gitflow?

Ideal ParaReleases PlanejadasMúltiplos AmbientesEquipes GrandesCiclos definidosVersões numeradasDevQAProdProcessos clarosResponsabilidadesdefinidas

Prós e Contras

Vantagens

✅ Estrutura clara e definida
✅ Ideal para releases planejadas
✅ Suporte a hotfixes
✅ Processos bem documentados

Desvantagens

❌ Mais complexo que feature branch
❌ Overhead para projetos pequenos
❌ Curva de aprendizado maior
❌ Pode ser "pesado" demais

Dicas de Implementação

1. Ferramentas de Suporte

ToolsGit Flow CLIIDE PluginsCI/CDComandos automatizadosMenos errosVisual feedbackIntegraçãoAutomaçãoQualidade

2. Checklist de Release

📋 Release Checklist

1. [ ] Feature freeze
2. [ ] Criar branch release
3. [ ] Bump version
4. [ ] Testes de regressão
5. [ ] Documentação
6. [ ] Code freeze
7. [ ] Deploy staging
8. [ ] Merge em main
9. [ ] Tag version
10.[ ] Deploy prod

Conclusão

Gitflow é como um roteiro de filme bem planejado - tem pré-produção (develop), filmagem (features), edição (release) e até correções de última hora (hotfix). Quando bem executado, o resultado é um blockbuster!

SucessoPlanejamentoExecuçãoManutençãoBranches corretasMomento certoSeguir workflowManter padrõesReleases limpasHotfixes rápidos

Forking Workflow

Se o Feature Branch é uma festa na casa do Stifler e o Gitflow é o baile de formatura, o Forking Workflow é como organizar vários American Pie ao mesmo tempo - cada um tem sua própria versão, mas todos contribuem para a franquia!

O que é Fork?

Fork

Fork

Fork

Pull Request

Pull Request

Pull Request

Repositório Original

Seu Fork

Fork Dev 2

Fork Dev 3

Fluxo Básico

LocalSeu ForkRepo OriginalLocalSeu ForkRepo OriginalForkCloneDesenvolvimentoPushPull Request

Estrutura do Workflow

1. Setup Inicial

# Fork via interface do GitHub/GitLab

# Clone do seu fork
git clone https://github.com/seu-usuario/projeto.git

# Adicionar upstream
git remote add upstream https://github.com/projeto-original/projeto.git

2. Mantendo Sincronizado

Fetch

Merge

Push

Upstream/Original

Seu Fork

Suas Changes

Ciclo de Desenvolvimento

1. Atualizando seu Fork

# Buscar mudanças do original
git fetch upstream

# Atualizar sua main
git checkout main
git merge upstream/main

2. Feature Development

Processo de Contribuição

1. Preparando o Pull Request

Pull RequestCódigo LimpoTestesDocumentaçãoFormataçãoLintUnitáriosIntegraçãoREADMEComentários

2. Fluxo de Review

OriginalMaintainerDevOriginalMaintainerDevPull RequestReviewFeedbackUpdatesMerge

Boas Práticas

1. Organização de Branches

origem/
  ├── main
  └── feature/
      ├── nova-funcionalidade
      └── bugfix-importante

seu-fork/
  ├── main
  └── feature/
      └── sua-contribuicao

2. Commits Organizados

maindocs: atualiza READMEfeat: nova funçãotest: adiciona testesfix: corrige bug

Vantagens do Forking

BenefíciosIsolamentoControleColaboraçãoExperimentos SegurosSem Afetar OriginalReview RigorosoQualidade CódigoComunidade AmplaMúltiplos Times

Desafios Comuns

1. Sincronização

Resolve

Update

Rebase

Conflitos

Merge

Desatualizado

Sync

Divergência

Align

2. Checklist de Contribuição

📋 Antes do PR:

1. [ ] Fork atualizado
2. [ ] Código testado
3. [ ] Docs atualizados
4. [ ] Commits organizados
5. [ ] Branch limpa

Ferramentas Úteis

1. GitHub/GitLab Features

ToolsInterface WebAutomaçãoColaboraçãoFork ButtonPR TemplatesCI/CDChecksReviewsDiscussions

2. Comandos Essenciais

# Sincronizar com upstream
git fetch upstream
git merge upstream/main

# Atualizar fork remoto
git push origin main

# Criar feature
git checkout -b feature/nova

Dicas de Sucesso

1. Comunicação

ComunicaçãoIssuesPR DescriptionFeedbackDiscutir AntesPlanejar MudançasContexto ClaroScreenshotsConstrutivoRespeitoso

2. Manutenção

🔄 Rotina de Manutenção

Daily:
  - Sync com upstream
  - Review PRs
  - Responder issues

Weekly:
  - Cleanup branches
  - Update docs
  - Check stale PRs

Conclusão

O Forking Workflow é como criar seu próprio American Pie enquanto contribui para a saga original - você tem liberdade criativa, mas precisa manter a essência que fez a franquia um sucesso!

Fork SuccessPreparaçãoExecuçãoContribuiçãoFork AtualizadoAmbiente ConfigCódigo LimpoTestes OKPR ClaroFeedback Loop

Gerenciamento de Releases

Como diria o Stifler: "Uma release é como uma festa - precisa de planejamento, organização e saber a hora certa de lançar!"

Fundamentos de Release Management

1. Ciclo de Release

Planejamento

Desenvolvimento

Testes

Preparação

Lançamento

Monitoramento

2. Tipos de Release

ReleasesMajorMinorPatchBreaking ChangesNovas ArquiteturasNovas FeaturesCompatívelHotfixesBugfixes

Versionamento Semântico

1. Estrutura

MAJOR.MINOR.PATCH
  |     |     |
  |     |     `-- Correções de bugs
  |     `-------- Novas funcionalidades
  `-------------- Breaking changes

2. Exemplos Práticos

Nova Feature

Bugfix

Breaking Change

1.0.0

1.1.0

1.1.1

2.0.0

Processo de Release

1. Preparação

MainRelease BranchDevelopMainRelease BranchDevelopBranch ReleaseTestesDocsMerge

2. Checklist de Release

📋 Release Checklist

1. [ ] Code Freeze
2. [ ] Versão Atualizada
3. [ ] Testes Completos
4. [ ] Documentação
5. [ ] Release Notes
6. [ ] Deploy Staging
7. [ ] Smoke Tests
8. [ ] Deploy Prod
9. [ ] Monitoramento
10.[ ] Comunicação

Estratégias de Release

1. Release Tradicional

mainrelease/1.00-74be4a7preptesttag v1.0

2. Continuous Delivery

ProdStagingTestesFeatureProdStagingTestesFeatureAuto TestsAuto DeployManual Approve

Ambientes de Deploy

1. Pipeline de Ambientes

Dev

QA

Staging

Production

2. Configuração por Ambiente

environments/
├── dev/
│   └── config.yml
├── qa/
│   └── config.yml
├── staging/
│   └── config.yml
└── prod/
    └── config.yml

Documentação de Release

1. Release Notes

Release NotesNovidadesCorreçõesBreaking ChangesFeaturesMelhoriasBugsPerformanceMigraçõesUpdates

2. Changelog

# Changelog

## [2.0.0] - 2024-02-20
### Added
- Nova interface
- API v2

### Changed
- Refatoração do core

### Fixed
- Bug #123
- Performance issue

Comunicação

1. Stakeholders

ComunicaçãoInternoExternoDev TeamSuporteUsuáriosClientes

2. Canais de Comunicação

📢 Canais

- Email Newsletter
- Blog Técnico
- Redes Sociais
- Documentação
- Release Notes

Monitoramento Pós-Release

1. Métricas Importantes

Performance

Monitoramento

Erros

Usage

Feedback

2. Plano de Rollback

RollbackBackupProdRollbackBackupProdBackupDeployMonitorSe Necessário

Automação

1. CI/CD Pipeline

Build

Test

Package

Deploy

Monitor

2. Scripts de Release

# Exemplo de script de release
./release.sh \
  --version="1.2.0" \
  --env="prod" \
  --backup \
  --notify

Melhores Práticas

1. Planejamento

Best PracticesTimingBackupTestesHorários Baixo UsoJanelas ManutençãoDadosConfiguraçõesRegressãoPerformance

2. Checklist de Segurança

🔒 Security Checklist

1. [ ] Backups atualizados
2. [ ] Secrets rotacionadas
3. [ ] Permissões verificadas
4. [ ] Logs habilitados
5. [ ] Monitoramento ativo

Conclusão

Como em American Pie, o timing é tudo! Uma release bem executada é como uma festa perfeita - todos se divertem e nada dá errado (ou pelo menos sabemos como lidar quando dá).

Release SuccessPreparaçãoExecuçãoPós-ReleasePlanejamentoTestesDeploy SuaveMonitoramentoFeedbackAjustes

Estratégias de Hotfix

Como o Stifler diria: "Bugs em produção são como aquela festa que começa a dar errado - você precisa agir rápido e com precisão!"

Anatomia de um Hotfix

1. Fluxo Básico

Branch

Fix

Deploy

Merge

Sync

Bug em Prod

Hotfix Branch

Teste

Prod

Main/Master

Develop

2. Estrutura de Branch

main/master
    |
    |--hotfix/bug-123
    |     |
    |     `-- fix
    |
    `-- merge

Tipos de Hotfix

1. Por Severidade

Hotfix TypesCriticalHighMediumSecurityData LossUX BreaksCore FeaturesMinor BugsUI Issues

2. Por Escopo

🔧 Hotfix Scopes

CRITICAL
├── Security Patches
├── Data Corruption
└── System Crash

URGENT
├── Business Logic
├── Payment Issues
└── Core Features

STANDARD
├── UI Fixes
├── Performance
└── Minor Bugs

Processo de Hotfix

1. Identificação

2. Execução

Create Branch

Fix Bug

Test

Review

Deploy

3. Checklist de Hotfix

🚨 Hotfix Checklist

1. [ ] Identificar causa raiz
2. [ ] Criar branch hotfix
3. [ ] Implementar correção
4. [ ] Testes de regressão
5. [ ] Code review
6. [ ] Deploy em staging
7. [ ] Validação
8. [ ] Deploy em prod
9. [ ] Merge em main
10.[ ] Sync develop

Comandos Git para Hotfix

1. Workflow Git

# Criar hotfix branch
git checkout -b hotfix/bug-123 main

# Commit fix
git commit -m "fix: corrige bug crítico #123"

# Merge em main
git checkout main
git merge --no-ff hotfix/bug-123

# Sync develop
git checkout develop
git merge --no-ff hotfix/bug-123

Boas Práticas

1. Regras de Ouro

Best PracticesMinimal ChangesQuick ProcessDocumentationOnly FixNo FeaturesFast ReviewQuick DeployRoot CauseSolution

2. Comunicação

📢 Communication Flow

1. Alert Team
2. Assess Impact
3. Plan Fix
4. Update Status
5. Deploy Notice
6. Resolution Note

Prevenção

1. Monitoramento

Logs

Detection

Metrics

Alerts

Quick Response

2. Checklist Preventivo

🛡️ Prevention Checklist

1. [ ] Monitoring setup
2. [ ] Alert thresholds
3. [ ] Backup strategy
4. [ ] Rollback plan
5. [ ] Team contacts

Documentação

1. Template de Hotfix

🔥 Hotfix Documentation

Issue: #123
Severity: Critical
Impact: Payment System

Root Cause:
- Invalid transaction handling

Fix:
- Added validation
- Updated error handling

Testing:
- Unit tests added
- Integration verified
- Staging validated

2. Post-Mortem

Post-MortemWhat HappenedResolutionPreventionTimelineImpactFixDeployLessonsUpdates

Automação

1. Pipeline de Hotfix

Branch

Build

Test

Review

Deploy

2. Scripts Automatizados

#!/bin/bash
# hotfix.sh

VERSION=$1
BRANCH="hotfix/$VERSION"

git checkout -b $BRANCH main
# run tests
# deploy staging
# await approval
# deploy prod

Métricas e KPIs

1. Indicadores Chave

MTTR

Metrics

Frequency

Success Rate

Impact Time

2. Dashboard

📊 Hotfix Metrics

MTTR: 45min
Success Rate: 98%
Frequency: 2/month
Impact Time: 30min

Conclusão

Como o Stifler aprendeu: em emergências, mantenha a calma, siga o processo e aja rápido! Um bom processo de hotfix é como ter um extintor de incêndio sempre à mão - você torce para não precisar, mas quando precisa, salva a festa!

Hotfix SuccessProcessQualityFollow-upQuickPreciseTestedReviewedDocumentLearn

Comparando Workflows

Se os workflows fossem festas do American Pie, seria assim:

  • Trunk-Based: Festa informal na casa do Jim

  • Feature Branch: Festa na casa do Stifler

  • Gitflow: Baile de formatura

  • Fork: Festival com várias stages

Visão Geral

WorkflowsTrunk-BasedFeature BranchGitflowForkSimplesRápidoContínuoIsoladoFlexívelColaborativoEstruturadoVersionadoComplexoDistribuídoComunidadeIndependente

Comparação Detalhada

1. Complexidade vs Flexibilidade

IdealComplexoLimitadoSimplesForkGitflowFeature-BranchTrunk-BasedBaixa ComplexidadeAlta ComplexidadeBaixa FlexibilidadeAlta FlexibilidadeComplexidade vs Flexibilidade

2. Tabela Comparativa

Aspecto

Trunk-Based

Feature Branch

Gitflow

Fork

Complexidade

Baixa

Média

Alta

Alta

CI/CD

Excelente

Bom

Moderado

Variável

Review

Rápido

Bom

Detalhado

Comunitário

Releases

Contínuas

Flexíveis

Planejadas

Independentes

Time Size

Pequeno

Médio

Grande

Distribuído

Cenários de Uso

1. Por Tamanho de Projeto

2. Por Tipo de Entrega

📦 Release Strategy Match

Continuous Delivery
└── Trunk-Based Development

Regular Releases
├── Feature Branch
└── Gitflow

Community/Open Source
└── Fork

Pontos Fortes

1. Trunk-Based

Trunk-BasedVelocidadeSimplicidadeDeploy RápidoCI/CD EficienteMenos BranchesMenos Conflitos

2. Feature Branch

Feature BranchIsolamentoColaboraçãoDesenvolvimento SeguroTestes IndependentesCode ReviewFeature Toggle

3. Gitflow

GitflowOrganizaçãoControleBranches DefinidasProcesso ClaroReleases PlanejadasHotfix Support

4. Fork

ForkIndependênciaComunidadeTrabalho IsoladoExperimentaçãoOpen SourceContribuições

Desafios Comuns

1. Problemas e Soluções

🎯 Workflow Challenges

Trunk-Based
├── Qualidade de Código
└── Feature Flags

Feature Branch
├── Long-Living Branches
└── Merge Hell

Gitflow
├── Complexidade
└── Overhead

Fork
├── Sincronização
└── Divergência

2. Mitigação de Riscos

Riscos

Automação

Code Review

CI/CD

Documentação

Escolhendo um Workflow

1. Critérios de Decisão

DecisãoTimeProjetoEntregaTamanhoDistribuiçãoComplexidadeEscalaFrequênciaProcesso

2. Matriz de Decisão

🎯 Decision Matrix

Small Team + Fast Delivery
└── Trunk-Based

Medium Team + Regular Releases
└── Feature Branch

Large Team + Structured Releases
└── Gitflow

Open Source + Community
└── Fork

Migração entre Workflows

1. Processo de Transição

Atual

Planejamento

Piloto

Migração

Consolidação

2. Checklist de Migração

📋 Migration Checklist

1. [ ] Avaliar workflow atual
2. [ ] Definir novo workflow
3. [ ] Treinar equipe
4. [ ] Projeto piloto
5. [ ] Migração gradual
6. [ ] Documentação
7. [ ] Monitoramento

Ferramentas e Automação

1. Stack Tecnológica

ToolsGitCI/CDReviewGitHub/GitLabBitbucketJenkinsGitHub ActionsPull RequestsCode Review

2. Automações Essenciais

🤖 Automation Must-Haves

CI/CD Pipeline
├── Build
├── Test
└── Deploy

Code Quality
├── Linting
├── Testing
└── Coverage

Branch Protection
├── Reviews
└── Checks

Conclusão

Como escolher entre as festas do American Pie, a escolha do workflow depende do seu "estilo de festa":

EscolhaVelocidadeFlexibilidadeEstruturaComunidadeTrunk-BasedFeature BranchGitflowFork

Lembre-se: não existe workflow perfeito, existe o workflow certo para seu contexto. Como diria o Stifler: "A melhor festa é aquela que funciona pro seu grupo!"

Migração de Workflow

Como mudar de festa sem estragar a diversão? Vamos aprender a migrar entre workflows de forma suave e segura!

Planejamento da Migração

1. Avaliação Inicial

AvaliaçãoAtualDestinoTimeProjetoPontos FortesProblemasBenefíciosDesafiosTamanhoHabilidadesComplexidadeRequisitos

2. Matriz de Impacto

📊 Impact Matrix

Alto Impacto/Alta Urgência
├── CI/CD Pipeline
└── Branch Strategy

Alto Impacto/Baixa Urgência
├── Code Review Process
└── Release Schedule

Baixo Impacto/Alta Urgência
├── Commit Standards
└── Documentation

Baixo Impacto/Baixa Urgência
├── Tool Updates
└── Optional Features

Estratégias de Migração

1. Big Bang vs Gradual

Escolha Estratégia

Big Bang

Gradual

Rápido

Arriscado

Seguro

Lento

2. Abordagem Gradual

Plano de Migração

1. Fases do Processo

Preparação

Piloto

Expansão

Consolidação

Manutenção

2. Checklist por Fase

📋 Migration Phases

Preparação:
├── Análise atual
├── Define objetivos
├── Planeja mudanças
└── Prepara docs

Piloto:
├── Seleciona time
├── Implementa teste
├── Coleta feedback
└── Ajusta plano

Expansão:
├── Treina times
├── Migra gradual
├── Monitora
└── Suporte

Consolidação:
├── Valida processo
├── Ajusta final
├── Documenta
└── Celebra

Gestão de Riscos

1. Matriz de Riscos

2. Plano de Contingência

🚨 Contingency Plan

Perda de Código:
├── Backup completo
└── Rollback plan

Resistência Time:
├── Treinamento
└── Suporte dedicado

Bugs CI/CD:
├── Ambiente paralelo
└── Testes extensivos

Atraso Projeto:
├── Buffer timeline
└── Recursos extras

Treinamento e Suporte

1. Plano de Capacitação

TreinamentoConceitosPráticaSuporteNovo WorkflowBenefíciosHands-onExemplosDocumentaçãoMentoria

2. Material de Apoio

📚 Support Material

Documentação:
├── Guias
├── Tutoriais
└── FAQ

Recursos:
├── Vídeos
├── Workshops
└── Templates

Suporte:
├── Chat
├── Office Hours
└── Buddy System

Métricas e Monitoramento

1. KPIs de Migração

MétricasVelocidadeQualidadeAdoçãoLead TimeCycle TimeBuild SuccessBug RateUsage RateCompliance

2. Dashboard de Acompanhamento

📊 Migration Dashboard

Daily Metrics:
├── Build Status
├── PR Flow
└── Issues

Weekly Review:
├── Team Adoption
├── Performance
└── Blockers

Monthly Analysis:
├── Success Rate
├── ROI
└── Satisfaction

Comunicação

1. Plano de Comunicação

Anúncio

Updates

Feedback

Ajustes

2. Canais e Frequência

📢 Communication Channels

Daily:
├── Stand-up
└── Chat Updates

Weekly:
├── Team Meeting
└── Progress Report

Monthly:
├── Review
└── Newsletter

Rollback Strategy

1. Plano de Reversão

RollbackAvaliaçãoProblemaRollbackAvaliaçãoProblemaIdentificaAnalisaDecideExecuta

2. Checklist de Rollback

⏮️ Rollback Checklist

1. [ ] Backup dados
2. [ ] Notifica time
3. [ ] Para processos
4. [ ] Reverte mudanças
5. [ ] Valida sistema
6. [ ] Comunica status

Conclusão

Como diria o Stifler: "Mudar de festa no meio da noite é arriscado, mas com o plano certo, a diversão continua!"

SucessoPreparaçãoExecuçãoSuportePlanejamentoTreinamentoGradualMonitoradaContínuoAdaptativo

Dicas Finais

1. Do's and Don'ts

✅ Do's:
├── Planeje bem
├── Comunique sempre
├── Monitore tudo
└── Celebre conquistas

❌ Don'ts:
├── Pressa excessiva
├── Ignorar feedback
├── Pular testes
└── Esquecer backup

2. Fatores de Sucesso

SucessoPessoasProcessoTecnologiaEngajamentoSuporteClarezaFlexibilidadeFerramentasAutomação

Boas Práticas de Workflow

Como diria o pai do Jim: "Não importa a festa que você escolhe, o importante é não fazer besteira!"

Princípios Fundamentais

Boas PráticasConsistênciaComunicaçãoAutomaçãoQualidadePadrõesConvençõesClaraDocumentadaCI/CDTestesCode ReviewTestes

Commits e Branches

1. Padrões de Commit

✍️ Commit Message Structure

<tipo>(<escopo>): <mensagem>

tipos:
├── feat     (nova feature)
├── fix      (correção bug)
├── docs     (documentação)
├── style    (formatação)
├── refactor (refatoração)
├── test     (testes)
└── chore    (manutenção)

2. Organização de Branches

main/master

develop

feature/*

bugfix/*

hotfix/*

Code Review

1. Checklist de Review

📋 Review Checklist

Código:
├── Clean Code
├── SOLID
├── DRY
└── Performance

Qualidade:
├── Testes
├── Cobertura
└── Documentação

Segurança:
├── Vulnerabilidades
└── Boas práticas

2. Processo de Review

CI/CDReviewerDevCI/CDReviewerDevPull RequestCode ReviewFeedbackUpdatesChecks PassApprove

Integração Contínua

1. Pipeline Básico

Commit

Build

Test

Lint

Deploy

2. Checklist de CI

🔄 CI Checklist

1. [ ] Build automatizado
2. [ ] Testes unitários
3. [ ] Testes integração
4. [ ] Análise estática
5. [ ] Security scan
6. [ ] Performance check

Documentação

1. Estrutura Recomendada

📚 Documentation Structure

projeto/
├── README.md
├── CONTRIBUTING.md
├── CHANGELOG.md
└── docs/
    ├── setup.md
    ├── workflow.md
    └── guidelines.md

2. Templates

TemplatesPull RequestIssueReleaseDescriçãoChecklistScreenshotsContextoReproduçãoEsperadoVersãoFeaturesFixes

Gestão de Releases

1. Versionamento

Semantic VersionMajorMinorPatchBreaking ChangesNew FeaturesBug Fixes

2. Processo de Release

Feature Freeze

Release Branch

Testing

Documentation

Version Tag

Deploy

Automação e Ferramentas

1. Stack Essencial

🛠️ Essential Tools

Versionamento:
├── Git
└── GitHub/GitLab

CI/CD:
├── Jenkins/GitHub Actions
└── Docker

Qualidade:
├── ESLint/SonarQube
└── Jest/PyTest

Documentação:
├── Markdown
└── Swagger/OpenAPI

2. Automações Recomendadas

AutomaçãoCommitsPRDeployLintFormatBuildTestStageProd

Resolução de Conflitos

1. Prevenção

🛡️ Conflict Prevention

1. Pull frequente
2. Branches curtas
3. Comunicação clara
4. Modularização
5. Feature flags

2. Resolução

Conflito

Comunicar

Analisar

Resolver

Testar

Commit

Métricas e Monitoramento

1. KPIs Importantes

MétricasVelocidadeQualidadeProcessoLead TimeCycle TimeBug RateTest CoveragePR TimeBuild Time

2. Checklist de Monitoramento

📊 Monitoring Checklist

Daily:
├── Build status
├── Test results
└── PR backlog

Weekly:
├── Code coverage
├── Tech debt
└── Performance

Monthly:
├── Process metrics
└── Team velocity

Dicas de Sucesso

1. Para o Time

SucessoComunicaçãoQualidadeProcessoDailyDocsReviewsTestsPadrõesAutomação

2. Checklist Diário

📋 Daily Checklist

1. [ ] Pull latest
2. [ ] Check CI/CD
3. [ ] Review PRs
4. [ ] Update docs
5. [ ] Communicate blockers

Conclusão

Como diria o Stifler: "As regras existem pra festa não virar bagunça!" Boas práticas são como as regras da festa - elas garantem que todo mundo se divirta sem criar problemas!

WorkflowConsistênciaQualidadeColaboraçãoPadrõesProcessosReviewsTestesComunicaçãoDocumentação

Automação de Workflow

Como diria o Stifler: "Por que fazer manual o que a máquina pode fazer por você?" Vamos explorar como automatizar nosso workflow!

Fundamentos da Automação

1. Pilares da Automação

AutomaçãoCI/CDQualidadeSegurançaProdutividadeBuildDeployTestesLintScansChecksScriptsBots

2. Benefícios Principais

🚀 Automation Benefits

Velocidade:
├── Build rápido
├── Deploy contínuo
└── Feedback imediato

Qualidade:
├── Testes automáticos
├── Code standards
└── Security checks

Consistência:
├── Processo padrão
├── Menos erros
└── Rastreabilidade

Pipeline CI/CD

1. Estrutura Básica

Commit

Build

Test

Lint

Security

Deploy

2. Configuração GitHub Actions

name: CI Pipeline
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        run: make build
      - name: Test
        run: make test
      - name: Lint
        run: make lint

Automação de Qualidade

1. Code Quality Gates

QualityLintTestsCoverageReviewESLintPrettierUnitIntegrationReportsThresholdPR TemplatesChecks

2. Checklist Automático

✅ Quality Checklist

Pre-commit:
├── Lint
├── Format
└── Tests

PR Creation:
├── Templates
├── Labels
└── Assignees

Merge Check:
├── Build
├── Coverage
└── Reviews

Bots e Integrações

1. GitHub Apps Essenciais

2. Configuração de Bots

# Dependabot config
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    labels:
      - "dependencies"
      - "automerge"

# Stale config
staleLabel: "stale"
daysUntilStale: 60
daysUntilClose: 7

Scripts de Automação

1. Scripts Úteis

#!/bin/bash

# Branch cleanup
cleanup() {
    git fetch -p
    git branch -vv | grep ': gone]' | awk '{print $1}' | xargs git branch -D
}

# Version bump
bump_version() {
    npm version $1
    git push && git push --tags
}

2. Hooks Git

🎣 Git Hooks

pre-commit:
├── Lint
└── Format

pre-push:
├── Tests
└── Build

post-merge:
├── Install deps
└── Clean cache

Monitoramento

1. Métricas Importantes

MetricsPipelineQualityPerformanceSuccess RateDurationCoverageIssuesBuild TimeDeploy Time

2. Dashboard

📊 Automation Dashboard

Build Status:
├── Success Rate
├── Duration
└── Failures

Quality Gates:
├── Coverage
├── Issues
└── Debt

Performance:
├── Build Time
├── Deploy Time
└── Queue Time

Segurança Automatizada

1. Security Checks

Code Push

SAST

Dependency Check

Secret Scanner

Container Scan

2. Security Pipeline

🔒 Security Pipeline

Static Analysis:
├── SAST
└── Code Quality

Dependencies:
├── Audit
└── Updates

Secrets:
├── Scanner
└── Validator

Melhores Práticas

1. Guidelines

Best PracticesModularDocumentadoVersionadoReusávelManutenívelREADMECommentsConfigScripts

2. Checklist de Implementação

📋 Implementation Checklist

Setup:
├── CI/CD Pipeline
├── Quality Gates
└── Security Checks

Maintenance:
├── Monitor Metrics
├── Update Deps
└── Review Logs

Documentation:
├── Setup Guide
├── Troubleshooting
└── Best Practices

Troubleshooting

1. Problemas Comuns

IssuesPipelineIntegrationPerformanceTimeoutFailuresConflictsAccessSlowHeavy

2. Debug Guide

🔍 Debug Steps

Pipeline Issues:
├── Check Logs
├── Verify Config
└── Test Local

Integration Problems:
├── Check Access
├── Verify Tokens
└── Test Connection

Conclusão

Como diria o Stifler: "Automatizar é como ter um amigo fazendo o trabalho chato enquanto você curte a festa!"

AutomaçãoEficiênciaConsistênciaEvoluçãoVelocidadeQualidadePadrõesProcessosMelhoriaAdaptação

Recursos Adicionais

1. Ferramentas Populares

🛠️ Popular Tools

CI/CD:
├── GitHub Actions
├── Jenkins
└── GitLab CI

Quality:
├── SonarQube
├── ESLint
└── Jest

Security:
├── Snyk
├── OWASP
└── Dependabot
📚 Resources

Docs:
├── GitHub Actions
├── Jenkins
└── GitLab CI

Tutorials:
├── CI/CD Setup
├── Bot Config
└── Scripts

Melhores Práticas em Controle de Versão

O controle de versão é fundamental para o desenvolvimento de software moderno. Aqui estão as práticas essenciais para manter seu código organizado e sua equipe produtiva.

Por que Seguir Boas Práticas?

BenefíciosQualidadeProdutividadeSegurançaCódigo LimpoRastreabilidadeMenos ConflitosColaboração EficienteBackupAuditoria

Princípios Fundamentais

1. Consistência

  • Mantenha padrões de código

  • Siga convenções de commit

  • Use nomenclatura uniforme

2. Atomicidade

  • Commits pequenos e focados

  • Uma feature por branch

  • Mudanças relacionadas juntas

3. Rastreabilidade

  • Commits descritivos

  • Referência a issues

  • Documentação atualizada

Organização de Repositório

Estrutura de Diretórios

projeto/
├── src/
├── tests/
├── docs/
├── .gitignore
└── README.md

Arquivos Essenciais

  • README.md

  • .gitignore

  • CONTRIBUTING.md

  • LICENSE

Commits

Anatomia de um Bom Commit

CommitTítuloCorpoMetadadosCurtoDescritivoImperativoContextoMotivaçãoImpactoIssue IDBreaking ChangesCo-authors

Padrão de Mensagens

Convenção de Commits

<tipo>(<escopo>): <descrição>

[corpo]

[footer]

Exemplos:
✅ feat(auth): adiciona autenticação via Google
✅ fix(api): corrige timeout em requisições longas
✅ docs(readme): atualiza instruções de instalação
✅ style(login): ajusta layout responsivo
✅ refactor(core): migra para TypeScript
✅ test(unit): adiciona testes para módulo de pagamento

Tipos de Commit

TiposFuncionalidadesCódigoDocumentaçãoInfraestruturaTestesfeatfixrefactorstyledocscommentsbuildcitestperf

Fluxo de Trabalho

ReviewGitDeveloperReviewGitDeveloperCodifica mudançasTesta localmentegit add [files]git commit -m "mensagem"Push para reviewFeedbackAjustes se necessário

Commits Atômicos

Sim

Não

Uma mudança lógica

Commit único

É atômico?

Perfect!

Dividir em
múltiplos commits

O que Evitar

❌ Commits Ruins:
└── "correções"
└── "wip"
└── "updates"
└── "fix bugs"
└── "commit final"
└── "alterações diversas"

✅ Commits Bons:
└── "feat(user): adiciona validação de email"
└── "fix(auth): corrige refresh token expirado"
└── "refactor(api): simplifica tratamento de erros"
└── "docs(swagger): atualiza documentação da API"

Dicas para Commits Efetivos

CommitsQuando CommitarComo CommitarPor que CommitarMudança completaTestes passandoCódigo revisadoMensagem claraMudanças relacionadasTamanho adequadoHistórico claroRastreabilidadeColaboração

Ferramentas Úteis

ToolsConventional CommitsGit HooksAutomaçãocommitlintcommitizenhuskypre-commitsemantic-releasestandard-version

Revisão de Commits

Novo Commit

Checklist

Mensagem clara?

Mudança atômica?

Testes incluídos?

Documentação atualizada?

Commit aprovado

Boas Práticas de Reescrita

🔄 Reescrita de Commits

Local (antes do push):
├── git commit --amend
├── git rebase -i
└── git reset

Remoto (com cuidado):
├── Squash merges
├── Rebase time
└── Force push (-f)

Gerenciamento de Branches

Fluxo de Desenvolvimento

maindevelopfeature/loginfeature/profile0-d272eb51-47893d82-a3cb6233-782367e5-186fe836-7791df5

Estrutura de Branches

main

develop

feature/*

bugfix/*

hotfix/*

release/*

Ciclo de Vida de uma Branch

ReviewFeatureDevelopMainReviewFeatureDevelopMainCriar branchDesenvolvimentoTestes locaisPull RequestCode ReviewAjustesMergeRelease

Convenções de Nomenclatura

BranchesFeatureBugfixHotfixReleasefeature/loginfeature/user-profilebugfix/login-errorbugfix/profile-crashhotfix/security-fixhotfix/critical-bugrelease/1.0.0release/2.0.0

Code Review

Checklist

  • [ ] Código segue padrões

  • [ ] Testes adicionados/atualizados

  • [ ] Documentação atualizada

  • [ ] Performance considerada

  • [ ] Segurança verificada

Feedback Construtivo

  • Foco no código, não no desenvolvedor

  • Sugestões específicas

  • Explicações claras

  • Reconhecimento de boas práticas

Terminologia do Controle de Versão

Conceitos Fundamentais

Repository (Repositório)

RepositórioLocalRemotoWorking DirectoryStaging AreaLocal RepositoryOriginUpstreamMirror
  • Local onde o código é armazenado

  • Contém todo o histórico do projeto

  • Pode ser local ou remoto

  • Inclui metadados e configurações

Branch (Ramo)

main

develop

feature/1

feature/2

hotfix

  • Linha independente de desenvolvimento

  • Permite trabalho paralelo

  • Isola mudanças em desenvolvimento

  • Facilita experimentações

Commit (Confirmação)

  • Snapshot do código em um momento

  • Inclui mensagem descritiva

  • Possui identificador único (hash)

  • Mantém autor e timestamp

Operações Básicas

Clone

LocalRepositório RemotoLocalRepositório RemotoCópia completagit cloneConfiguração local
  • Cria cópia local do repositório

  • Inclui todo histórico

  • Configura remote origin

  • Estabelece tracking branches

Pull

LocalRemotoLocalRemotogit fetchNovos commitsgit merge
  • Atualiza repositório local

  • Combina fetch + merge

  • Sincroniza com remoto

  • Resolve conflitos se necessário

Push

RemotoLocalRemotoLocalAtualiza remotoCommits locaisgit push
  • Envia commits locais

  • Atualiza repositório remoto

  • Requer permissões

  • Pode exigir resolução de conflitos

Operações Avançadas

Merge (Mesclagem)

mainfeature0-1a415281-46610d82-7c62fc73-2a16c92
  • Combina mudanças de diferentes branches

  • Pode gerar conflitos

  • Mantém histórico de ambas as branches

  • Cria commit de merge

Rebase (Rebase)

  • Reaplica commits sobre outra base

  • Mantém histórico linear

  • Útil para manter branches atualizadas

  • Altera histórico de commits

Cherry-pick

mainfeatureABCcherry-pick:C
  • Aplica commits específicos

  • Seletivo e preciso

  • Útil para hotfixes

  • Cria novos commits

Estados de Arquivos

Tracked (Rastreado)

git add

git commit

modificação

Modified

Staged

Committed

Modified (Modificado)

  • Arquivo alterado

  • Não preparado para commit

  • Detectado pelo git status

Staged (Preparado)

  • Marcado para commit

  • Na área de staging

  • Pronto para confirmação

Committed (Confirmado)

  • Salvo no repositório

  • Parte do histórico

  • Possui hash único

Untracked (Não Rastreado)

Sim

Não

Arquivo Novo

git add?

Tracked

Untracked

  • Arquivos novos

  • Não incluídos no controle de versão

  • Precisam ser adicionados explicitamente

  • Ignorados via .gitignore

Glossário Expandido

Termo

Definição

Uso Comum

Clone

Cópia completa do repositório

Início do trabalho

Fork

Cópia independente do repositório

Contribuição externa

Pull Request

Solicitação para integrar mudanças

Colaboração

Tag

Marco específico no histórico

Releases

Hook

Script automatizado em eventos

Automação

Remote

Repositório em servidor

Colaboração

Head

Ponteiro para commit atual

Referência

Index

Área de staging

Preparação

Stash

Armazenamento temporário

Mudança de contexto

Fetch

Download de mudanças

Atualização

Configurações e Metadados

Arquivos de Configuração

.git/
├── config
├── HEAD
├── index
├── objects/
└── refs/

Arquivos Especiais

projeto/
├── .gitignore
├── .gitattributes
├── .gitmodules
└── .git/

Fluxos de Trabalho

Básico

Modificar

Stage

Commit

Push

Colaborativo

Pull

Modificar

Commit

Push

Pull Request

Resolução de Problemas

Conflitos

Manual

Ferramenta

Conflito

Resolver

Editar Arquivo

Merge Tool

git add

git commit

Recuperação

Commit Errado

Perda de Arquivo

Branch Errada

Problema

Tipo

git reset

git checkout

git branch

Segurança em Controle de Versão

Fundamentos de Segurança

Princípios Básicos

SegurançaConfidencialidadeIntegridadeDisponibilidadeDados SensíveisCredenciaisTokensCommits AssinadosHistórico ProtegidoBranches ProtegidasBackupsRedundânciaDisaster Recovery

Proteção de Dados Sensíveis

Gerenciamento de Credenciais

Nunca

Sempre

Opção 1

Opção 2

Opção 3

Credenciais

Repositório

Gestão Segura

Variáveis de Ambiente

Cofre de Senhas

Serviços de Configuração

Arquivo .gitignore Robusto

# Arquivos de Configuração
.env
.env.*
config/*.json
secrets.yaml
credentials.ini

# Chaves e Certificados
*.pem
*.key
*.cert
*.crt
id_rsa*
*.ppk

# Diretórios Sensíveis
.ssh/
private/
secrets/
credentials/

# Logs e Temporários
*.log
tmp/
temp/
.cache/

# IDEs e Editores
.vscode/
.idea/
*.swp
*.swo

# Dependências e Builds
node_modules/
vendor/
dist/
build/

Controle de Acesso

Modelo de Permissões

Autenticação e Autorização

Métodos de Autenticação

  1. SSH

RepositórioUsuárioRepositórioUsuárioApresenta Chave PúblicaDesafioResposta AssinadaAcesso Concedido
  1. Tokens de Acesso

  • Tokens de curta duração

  • Escopos limitados

  • Revogação simples

  • Auditoria facilitada

  1. 2FA/MFA

Senha

Token

Biometria

Login

1º Fator

2º Fator

3º Fator

Acesso

Proteção de Branches

Regras de Proteção

Pull_Request

Code_Review

Testes

Aprovação

Merge

Configurações Recomendadas

  1. Branch Principal

    • Requer aprovações

    • Proíbe force push

    • Exige status checks

    • Mantém histórico linear

  2. Branches de Feature

    • Nomenclatura padronizada

    • Vida útil limitada

    • Merge apenas via PR

    • Testes automatizados

Monitoramento e Auditoria

Logs de Segurança

Coleta

Análise

Armazenamento

Ação

Eventos

Logs

Alertas

Histórico

Resposta

Métricas de Segurança

MétricasAcessosAlteraçõesVulnerabilidadesTentativasSucessosFalhasCommitsMergesDeploysExposiçõesCorreçõesTempo de Resposta

Vulnerabilidades Comuns

Tipos de Ameaças

Ameaças

Exposição de Dados

Acesso Não Autorizado

Manipulação de Histórico

Injeção de Código

Mitigação

  1. Ferramentas de Análise

    • Git-secrets

    • TruffleHog

    • GitGuardian

    • Gitleaks

  2. Hooks de Prevenção

#!/bin/sh
# pre-commit hook para detectar secrets
if git-secrets --scan; then
    exit 0
else
    echo "Secrets detectados! Commit bloqueado."
    exit 1
fi

Backup e Recuperação

Estratégias de Backup

Diário

Semanal

Mensal

Repositório

Backup Local

Backup Cloud

Backup Offline

Plano de Recuperação

VerificaçãoBackupRespostaDetecçãoIncidenteVerificaçãoBackupRespostaDetecçãoIncidenteProblema IdentificadoAvaliaçãoRecuperaçãoValidação

Melhores Práticas

Checklist de Segurança

  1. Repositório

    • [ ] .gitignore atualizado

    • [ ] Branches protegidas

    • [ ] Hooks configurados

    • [ ] Backups automatizados

  2. Acesso

    • [ ] 2FA habilitado

    • [ ] Tokens com escopo mínimo

    • [ ] Revisão regular de acessos

    • [ ] Logs de auditoria

  3. Código

    • [ ] Análise de secrets

    • [ ] Verificação de dependências

    • [ ] Assinatura de commits

    • [ ] Code review obrigatório

Automação de Segurança

Trigger

Falha

Falha

Falha

Sucesso

Sucesso

Sucesso

Push

CI/CD

Análise de Secrets

Scan de Vulnerabilidades

Verificação de Licenças

Bloqueia Deploy

Continua Deploy

Resposta a Incidentes

Plano de Ação

Detecção

Avaliação

Contenção

Erradicação

Recuperação

Lições Aprendidas

Documentação

  1. Registro de Incidentes

    • Data e hora

    • Tipo de incidente

    • Impacto

    • Ações tomadas

    • Resolução

  2. Análise Post-mortem

    • Causa raiz

    • Medidas preventivas

    • Melhorias necessárias

    • Atualizações de processo

Integração do Controle de Versão

A integração do controle de versão com outras ferramentas e sistemas é fundamental para um fluxo de trabalho moderno e eficiente.

Visão Geral

IntegraçõesCI/CDIDEsGestãoCode ReviewPipelineBuildDeployVSCodeIntelliJEclipseJiraTrelloAzure BoardsGitHubGitLabGerrit

Benefícios Principais

1. Automação

  • Redução de tarefas manuais

  • Menor probabilidade de erros

  • Processos padronizados

2. Produtividade

  • Fluxo de trabalho otimizado

  • Ferramentas integradas

  • Contexto unificado

3. Qualidade

  • Verificações automáticas

  • Feedback rápido

  • Rastreabilidade

Áreas de Integração

Explore cada área específica:

Melhores Práticas

Implementação

Análise de Necessidades

Seleção de Ferramentas

Configuração

Testes

Treinamento

Monitoramento

Manutenção

  1. Atualize regularmente

  2. Monitore integrações

  3. Colete feedback

  4. Otimize workflows

  5. Documente processos

Integração com CI/CD

A integração entre controle de versão e CI/CD (Integração Contínua/Entrega Contínua) automatiza o processo de build, teste e deploy.

Pipeline Básico

Trigger

Success

Pass

Production

Commit

Build

Test

Deploy

Monitor

Ferramentas Populares

1. GitHub Actions

name: CI
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        run: npm install && npm build
      - name: Test
        run: npm test

2. GitLab CI

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - npm install
    - npm build

3. Jenkins

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'npm install'
                sh 'npm build'
            }
        }
    }
}

Melhores Práticas

1. Configuração

  • Cache de dependências

  • Ambientes isolados

  • Variáveis secretas

  • Logs detalhados

2. Segurança

SegurançaSecretsScansPermissõesVaultENVSASTDASTRolesTokens

Monitoramento

Métricas Importantes

  • Tempo de build

  • Taxa de sucesso

  • Cobertura de testes

  • Vulnerabilidades

  • Performance

Integração com IDEs

A integração do controle de versão com IDEs (Ambientes de Desenvolvimento Integrado) proporciona uma experiência de desenvolvimento mais fluida.

IDEs Populares

1. Visual Studio Code

VSCodeGitGitHubGitLensGutterGraphBlamePRIssuesCopilotHistoryBlameSearch

2. IntelliJ IDEA

  • Git Integration

  • Merge Tools

  • Branch Management

  • Commit Interface

3. Eclipse

  • EGit Plugin

  • Team Synchronization

  • History View

  • Compare Editor

Recursos Essenciais

1. Visualização

  • Diff inline

  • Branch graph

  • Blame annotations

  • Change markers

2. Operações

Commit

Push

Amend

Revert

Sync

Force Push

Extensões Recomendadas

VSCode

  1. GitLens

  2. GitHub Pull Requests

  3. Git History

  4. Git Graph

IntelliJ

  1. Git Tool Box

  2. GitHub Copilot

  3. Git Flow Integration

Integração com Gestão de Projetos

A integração entre controle de versão e ferramentas de gestão de projetos melhora a rastreabilidade e o gerenciamento do trabalho.

Ferramentas Populares

1. Jira + Git

JiraGitDevJiraGitDevCommit com ID da IssueAtualiza StatusNotifica Mudança

2. Azure DevOps

  • Work Items

  • Boards

  • Repos

  • Pipelines

3. Trello + GitHub

  • Card Links

  • Automações

  • Power-Ups

Funcionalidades Principais

1. Rastreabilidade

Link

Referência

Trigger

Update

Issue

Branch

Commit

Pipeline

2. Automações

  • Status automático

  • Assignees

  • Labels

  • Milestones

Melhores Práticas

1. Nomenclatura

  • Branches com ID da issue

  • Commits com referências

  • PRs linkados

2. Workflows

Start

Commit

Merge

Todo

In Progress

Review

Done

Ferramentas de Code Review

As ferramentas de code review são essenciais para manter a qualidade do código e promover colaboração efetiva.

Plataformas Principais

1. GitHub Pull Requests

CIReviewPRDevCIReviewPRDevCria PRTrigger ChecksStatusSolicita ReviewAprova/Rejeita

2. GitLab Merge Requests

  • Discussões inline

  • Aprovações múltiplas

  • CI/CD integrado

  • Security scanning

3. Gerrit

  • Code-review específico

  • Verificação automatizada

  • Integração com CI

  • Workflows customizados

Funcionalidades Essenciais

1. Análise de Código

Code ReviewEstáticoSegurançaQualidadeLintStyleSASTDepsCoverageDuplicação

2. Colaboração

  • Comentários inline

  • Sugestões de código

  • Threads de discussão

  • Menções (@username)

Melhores Práticas

1. Processo

  1. Revisão automatizada

  2. Revisão humana

  3. Testes verificados

  4. Documentação atualizada

2. Checklist

✓ Código limpo
✓ Testes adequados
✓ Documentação
✓ Performance
✓ Segurança
✓ Standards

Automações Recomendadas

1. Checks Automáticos

  • Lint

  • Formatação

  • Testes unitários

  • Coverage

  • Vulnerabilidades

2. Integrações

Instalação e Setup

Instalação do Git

Windows

  1. Baixe o instalador em https://git-scm.com/download/windows

  2. Execute o arquivo .exe baixado

  3. Siga o assistente de instalação mantendo as opções padrão

  4. Verifique a instalação abrindo o terminal:

git --version

Linux (Debian/Ubuntu)

sudo apt-get update
sudo apt-get install git

macOS

  1. Via Homebrew:

brew install git
  1. Ou baixe o instalador em https://git-scm.com/download/mac

Configuração Inicial

Identidade

Configure seu nome e email que serão usados nos commits:

git config --global user.name "Seu Nome"
git config --global user.email "seu.email@exemplo.com"

Editor Padrão

Configure seu editor de texto preferido:

git config --global core.editor "code --wait"  # VS Code
git config --global core.editor "vim"          # Vim
git config --global core.editor "nano"         # Nano

Verificar Configurações

Liste todas as configurações atuais:

git config --list

Configurações Recomendadas

Aliases Úteis

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

Merge e Diff

git config --global merge.tool vimdiff
git config --global diff.tool vimdiff

Final de Linha

Windows:

git config --global core.autocrlf true

Linux/macOS:

git config --global core.autocrlf input

Integrações

Configurar SSH

  1. Gerar chave SSH:

ssh-keygen -t ed25519 -C "seu.email@exemplo.com"
  1. Adicionar ao ssh-agent:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
  1. Copiar chave pública:

cat ~/.ssh/id_ed25519.pub
  1. Adicionar a chave no GitHub/GitLab

Autenticação HTTPS

Para evitar digitar senha constantemente:

git config --global credential.helper store  # Permanente
git config --global credential.helper cache  # Temporário

Troubleshooting

Problemas Comuns

  1. Git não reconhecido no terminal

    • Verifique a variável PATH

    • Reinstale o Git

  2. Erro de autenticação

    • Verifique suas credenciais

    • Regenere suas chaves SSH

    • Use token de acesso pessoal

  3. Problemas de configuração

    • Reset configurações: git config --global --reset

    • Reconfigurar do zero

Próximos Passos

  1. Verifique a instalação

  2. Configure sua identidade

  3. Configure seu editor

  4. Configure suas chaves SSH

  5. Teste um clone de repositório

Agora você está pronto para começar a usar o Git. Continue para Primeiros Passos (Primeiros Passos).

História do Git

The simpsons homer
The simpsons homer

Para começar a historia do Git é até bem curta e direta. A comunidade do Linux usava um VCS distribuído chamado BitKeeper só que ele é proprietário.

Sim, um sistema open source usando um proprietário. Claramente isso era algo que causava um estranhamento na comunidade.

Stifler kiss
Stifler kiss

Que por sua vez chegou ao ápice quando o BitKeeper se tornou pago, logo a comunidade do Linux ficou alerta já que eles teriam que fazer o versionamento do núcleo do Linux em outro sistema.

Assim então a comunidade começou a criar seu próprio VCS que fosse:

  • Simples

  • Veloz

  • Não linear, ou seja, que aceite vários ramos (branches) de modificação

  • Capaz de lidar com grandes projetos, afinal, Linux é gigante

E assim nasceu o Git, exatamente em 2005 e até hoje está em evolução sendo um dos VCS mais utilizados em todo o mundo de desenvolvimento de gambiarras (softwares).

Ou seja, tudo nasceu de uma revolta popular

Cachorro comuna
Cachorro comuna

Linha do Tempo Detalhada

2002Início do uso doBitKeeperLinux kernel adotaBitKeeperLicença gratuita paraopen source2005ControvérsiaBitKeeperFim da licençagratuitaLinus inicia Git2005 AbrilPrimeira versão doGitAuto-hospedagemdo kernelAdoção pelacomunidade2005 JunhoKernel Linux migrapara GitPrimeira versãoestável2007Adoção massivacomeçaGitHub é fundado2008Git 1.6 lançadoMelhorias deperformance2010Git 1.7Novos recursos2015Git 2.0Mudançassignificativas2020Git 2.30Suporte a maincomo padrãoA Origem do Git

Por que o Git Deu Certo?

Pontos Fortes Iniciais

GitPerformanceDistribuídoDesignGratuitoRápidoEficienteCompactoSem Servidor CentralTrabalho OfflineBackup NaturalSimplesFlexívelConfiávelOpen SourceSem CustosComunidade Forte

Motivações Técnicas

RequisitosVelocidadeDistribuiçãoIntegridadeOperações locaisOtimização deltaCompressão eficienteSem servidor centralMúltiplos backupsTrabalho offlineHash SHA-1Histórico imutávelVerificação criptográfica

Como o Git Funciona

Sistema de Objetos

Aponta para

Contém

Referencia

Subdiretório

Arquivo

Commit

Tree

Blob

Parent

Tree

Estrutura Interna

git add

git commit

git checkout

git fetch

git push

Working Directory

Staging Area

Repository

Remote

Sistema de Branches

mainfeaturehotfix0-6e8c55f1-70529f32-564d0544-f63a7995-160c19c

Evolução e Impacto

Adoção Global

95%3%1%1%Uso de VCS em 2023GitSVNMercurialOutros

Crescimento do GitHub

2008Fundação2009100k repositórios20111M repositórios20135M repositórios201520M repositórios2018Aquisição Microsoft2020100M repositórios2023200M+ repositóriosMarcos do GitHub

Ecossistema Atual

Plataformas Principais

GitGitHubGitLabBitbucketActionsCopilotPagesPackagesCodespacesCI/CDContainer RegistryWikiIssuesSecurityPipelinesCode ReviewJira IntegrationBambooConfluence

Ferramentas Populares

ToolsGUI ClientsIDE IntegrationCLI EnhancersGitKrakenSourceTreeGitHub DesktopTowerVS CodeIntelliJEclipseAtomOh My ZshGit ExtensionsHubGit Flow

Inovações Recentes

GitHub Copilot

AI Analysis

Developer Review

Feedback

Código

Sugestões

Implementation

Codespaces

Launch

Development

Commit

Repository

Cloud IDE

Changes

Futuro do Git

FuturoPerformanceSegurançaUsabilidadeCloudAI IntegrationPartial ClonesSparse CheckoutsBetter CompressionMulti-threadingSHA-256Signing2FA/MFAVulnerability ScanningBetter UISimplified CommandsIDE IntegrationNatural Language InterfaceVirtual FSStreamingReal-time CollabCross-platform SyncSmart MergingCode AnalysisConflict ResolutionAutomated Reviews

Impacto na Indústria

Transformação do Desenvolvimento

ImpactoColaboraçãoDevOpsMetodologiasOpen SourceCode ReviewPull RequestsCI/CDAutomaçãoDeployTrunk BasedGitFlowFeature Toggle

Recursos Adicionais

Documentação Oficial

Comunidade

Tutoriais e Cursos

Curiosidades

Origem do Nome

Linus Torvalds: "Eu sou um bastardo egoísta, e nomeio todos os meus projetos com meu nome. Primeiro Linux, agora Git"

(Git em gíria britânica significa "pessoa desagradável")

Recordes

  • Maior repositório Git: Android Open Source Project (>100GB)

  • Commit mais antigo ainda ativo: Kernel Linux (2005)

  • Maior plataforma: GitHub (200M+ repositórios)

Easter Eggs

git help --all   # Lista todos os comandos, incluindo alguns divertidos
git help everyday # Guia de uso diário
git help tutorial # Tutorial básico

Conceitos Básicos do Git

Como o Git Funciona

O Git funciona de forma diferente de outros VCS. Em um outro VCS ele terá os arquivos e quando houver alteração eles criam uma lista somente das alterações.

Em um outro VCS ele terá os arquivos e quando houver alteração eles criam uma lista somente das alterações:

Version control system basico outros vcs
Version control system basico outros vcs

Agora com o Git ele faz diferente, já que vai tirando snapshots que são como fotos quando ocorre uma mudança e caso tenha algum arquivo que não foi alterado será guardado uma referencia para ele, assim pode ser recuperado.

Estrutura de Diretórios

Assim temos três níveis principais:

  • Diretório de trabalho (Working Directory)

  • Área de preparo (Staging Area)

  • Diretório .git que vai ser o repositório ou banco de dados local

Version control system fluxodetrabalho
Version control system fluxodetrabalho
Diretórios quando se trabalha com Git

Working Directory

É onde você realmente trabalha com seus arquivos. Aqui você pode:

  • Criar novos arquivos

  • Modificar arquivos existentes

  • Deletar arquivos

Edição

git add

Working Directory

Arquivos Modificados

Staging Area

Staging Area

Também conhecida como "Index", é uma área intermediária onde você prepara as mudanças que farão parte do próximo commit.

git add

git commit

git reset

Arquivos Modificados

Staging Area

Repositório

Repositório Local (.git)

O coração do Git, onde todo o histórico do projeto é armazenado:

  • Commits

  • Branches

  • Tags

  • Configurações

Estados dos Arquivos

Ciclo de Vida

Novo arquivo

git add

git commit

Edição

git add

Untracked

Staged

Committed

Modified

Estados Possíveis

  1. Untracked: Arquivos que o Git não conhece

  2. Tracked: Arquivos que o Git está monitorando

    • Modified: Alterados mas não preparados

    • Staged: Preparados para commit

    • Committed: Salvos no repositório

Comandos Básicos Essenciais

Configuração Inicial

# Configuração global
git config --global user.name "Stifler"
git config --global user.email "stifler@milfsgo.com"

# Configuração local (por repositório)
git config user.name "Stifler"
git config user.email "stifler@milfsgo.com"

Iniciando um Repositório

# Criar novo repositório
git init

# Clonar repositório existente
git clone https://github.com/user/repo.git

Operações Básicas

# Verificar status
git status

# Adicionar arquivos
git add arquivo.txt    # Arquivo específico
git add .              # Todos os arquivos

# Criar commit
git commit -m "feat: adiciona função de busca de milfs"

# Ver histórico
git log
git log --oneline     # Formato resumido
git log --graph       # Com representação gráfica

Boas Práticas de Commit

Mensagens de Commit

MensagemTítuloCorpoCurtoImperativoDescritivoContextoRazãoImpacto

Conventional Commits

Padrão para mensagens de commit:

  • feat: Nova funcionalidade

  • fix: Correção de bug

  • docs: Documentação

  • style: Formatação

  • refactor: Refatoração

  • test: Testes

  • chore: Tarefas gerais

feat: adiciona busca por localização
fix: corrige bug no filtro de idade
docs: atualiza README

Desfazendo Alterações

No Working Directory

# Descartar mudanças em arquivo
git checkout -- arquivo.txt

# Descartar todas as mudanças
git checkout -- .

Na Staging Area

# Remover arquivo do stage
git reset HEAD arquivo.txt

# Remover todos os arquivos
git reset HEAD .

Em Commits

# Desfazer último commit mantendo alterações
git reset --soft HEAD^

# Desfazer último commit descartando alterações
git reset --hard HEAD^

Branches

Conceitos Básicos

mainfeature0-73a95011-b4776c12-cba448e

Operações com Branches

# Criar branch
git branch nova-feature

# Mudar de branch
git checkout nova-feature

# Criar e mudar (atalho)
git checkout -b nova-feature

# Listar branches
git branch

# Deletar branch
git branch -d nova-feature

Merge e Rebase

Merge

Merge

Merge

Main

Merge Commit

Feature

git checkout main
git merge feature

Rebase

Rebase

Linear

Main

Feature

História Final

git checkout feature
git rebase main

Resolução de Conflitos

Tipos Comuns de Conflitos

  1. Edição na mesma linha

  2. Arquivo deletado x modificado

  3. Renomeação x modificação

Processo de Resolução

Identificar

Escolher

Marcar Resolvido

Finalizar

Conflito Detectado

Analisar Diferenças

Editar Arquivo

git add

git commit

Dicas e Truques

Aliases Úteis

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

Ferramentas Visuais

  • GitKraken

  • SourceTree

  • GitHub Desktop

  • VS Code Git

Produtividade

Git ProAliasesAuto-completeGUIIDEComandos curtosCombinaçõesBashZshVisualizaçãoHistóricoIntegraçãoPlugins

Próximos Passos

O que Estudar Depois

  1. Git Remoto (GitHub, GitLab, etc)

  2. Workflows avançados

  3. Git Hooks

  4. CI/CD com Git

Recursos Recomendados

Dica: Pratique! Git é como andar de bicicleta, só se aprende fazendo (e ocasionalmente caindo)

Primeiros Passos

Iniciando um Repositório

Novo Repositório

mkdir meu-projeto
cd meu-projeto
git init

Clonar Repositório Existente

git clone https://github.com/usuario/repositorio.git
git clone git@github.com:usuario/repositorio.git  # Via SSH

Ciclo Básico do Git

Status do Repositório

git status  # Ver estado atual
git log     # Ver histórico

Adicionando Arquivos

git add arquivo.txt          # Arquivo específico
git add .                    # Todos os arquivos
git add diretorio/*         # Todo conteúdo do diretório

Criando Commits

git commit -m "Mensagem descritiva do commit"
git commit -am "Commit com add automático"

Trabalhando com Branches

Gerenciamento Básico

git branch                   # Listar branches
git branch nova-feature     # Criar branch
git checkout nova-feature   # Mudar de branch
git checkout -b outra-feature # Criar e mudar

Merge de Branches

git checkout main           # Volta para main
git merge nova-feature     # Merge da feature

Sincronização com Remoto

Configurar Remoto

git remote add origin https://github.com/usuario/repo.git
git remote -v              # Listar remotos

Push e Pull

git push origin main      # Enviar alterações
git pull origin main      # Receber alterações

Boas Práticas

Commits

  1. Mensagens claras e descritivas

  2. Um commit por alteração lógica

  3. Prefixos comuns:

    • feat: nova funcionalidade

    • fix: correção de bug

    • docs: documentação

    • style: formatação

    • refactor: refatoração

    • test: testes

Branches

  1. Nomes descritivos

  2. Use prefixos:

    • feature/

    • bugfix/

    • hotfix/

    • release/

Fluxo de Trabalho Básico

  1. Atualizar branch principal

git checkout main
git pull origin main
  1. Criar branch de feature

git checkout -b feature/nova-funcionalidade
  1. Fazer alterações

git add .
git commit -m "feat: adiciona nova funcionalidade"
  1. Enviar alterações

git push origin feature/nova-funcionalidade

Resolução de Problemas

Reverter Alterações

git checkout -- arquivo.txt  # Descarta alterações
git reset --hard HEAD       # Reseta para último commit
git revert commit-hash      # Reverte commit específico

Correções Comuns

git commit --amend          # Corrigir último commit
git reset HEAD arquivo.txt  # Remover do stage

Próximos Passos

  1. Pratique os comandos básicos

  2. Crie alguns repositórios de teste

  3. Experimente trabalhar com branches

  4. Faça push/pull com repositório remoto

  5. Avance para Workflows (Automação de Workflow)

Exercícios Práticos

  1. Crie um novo repositório

  2. Adicione alguns arquivos

  3. Faça commits

  4. Crie uma branch

  5. Faça merge

  6. Sincronize com GitHub

Lembre-se: a prática leva à perfeição. Quanto mais você usar estes comandos, mais natural o fluxo se tornará.

Git Debug

+------------------------+
|      Git Debug        |
|                       |
| Diagnóstico           |
| Troubleshooting       |
| Resolução             |
|                       |
| Debugging Avançado    |
+------------------------+

Ferramentas de Debug

Variáveis de Ambiente

# Debug geral
GIT_TRACE=1

# Debug específico
GIT_TRACE_PACKET=1     # Protocolo
GIT_TRACE_PACK_ACCESS=1 # Acesso packfile
GIT_TRACE_PERFORMANCE=1 # Performance
GIT_TRACE_SETUP=1      # Setup
GIT_CURL_VERBOSE=1     # HTTP

Comandos Essenciais

DebugVerificaçãoLogsEstadofsckverify-packrefloglogstatusremote -v

Técnicas de Diagnóstico

Verificação de Integridade

# Verificar repositório
git fsck --full

# Verificar objetos
git verify-pack -v .git/objects/pack/*.idx

# Verificar refs
git for-each-ref --verify

Análise de Logs

+------------------------+
|    NÍVEIS DE LOG      |
|                       |
| • Trace              |
| • Debug              |
| • Info               |
| • Warning            |
| • Error              |
+------------------------+

Problemas Comuns

Network Issues

ServerClientServerClientDebug com GIT_CURL_VERBOSEgit fetchtimeoutretry com trace

Resolução

# Problemas de rede
GIT_CURL_VERBOSE=1 git clone <url>

# Problemas de autenticação
ssh -vT git@github.com

# Problemas de objeto
git prune && git gc

Debug Avançado

Análise de Performance

# Trace detalhado
GIT_TRACE_PERFORMANCE=1 git status

# Estatísticas de objetos
git count-objects -v

# Profiling
git maintenance run --task=gc --verbose

Ferramentas Externas

ToolsGitIDESistemagit-bisectgit-blamedebuggerprofilerstracedtrace

Boas Práticas

Prevenção

+------------------------+
|    CHECKLIST          |
|                       |
| • Backup regular     |
| • Verificações       |
| • Manutenção        |
| • Monitoramento     |
| • Documentação      |
+------------------------+

Workflow de Debug

  1. Identificar sintomas

  2. Coletar informações

  3. Reproduzir problema

  4. Analisar logs

  5. Aplicar solução

  6. Verificar resolução

Automação

Scripts Úteis

#!/bin/bash
# Debug completo
debug_git() {
    export GIT_TRACE=1
    export GIT_TRACE_PERFORMANCE=1
    export GIT_TRACE_PACKET=1
    git "$@"
    unset GIT_TRACE GIT_TRACE_PERFORMANCE GIT_TRACE_PACKET
}

Monitoramento

Logs

Alertas

Resolução

Coleta

Análise

Ação

Verificação

Recuperação

Dados Perdidos

# Recuperar commits deletados
git reflog

# Recuperar arquivos deletados
git fsck --lost-found

# Restaurar estado anterior
git reset --hard HEAD@{1}

Corrupção

# Verificar e reparar
git fsck --full
git prune
git gc --aggressive

# Clonar novamente se necessário
git clone --mirror <url>

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um registro de problemas encontrados e suas soluções para referência futura.

Fluxo de Trabalho do Git

Iniciando um Repositório

Devemos usar o comando abaixo para iniciar o repositório para que o Git consiga ver os arquivos.

md MilfsGo # Cria a pasta
cd MilfsGo # acessa a pasta
git init

Ciclo de Vida dos Arquivos

Estados dos Arquivos

Novo arquivo

git add

git commit

Edição

git add

Untracked

Staged

Committed

Modified

Áreas do Git

git add

git commit

git checkout

Working Directory

Staging Area

Repository

Fazendo Alterações

Agora vamos fazer alterações básicas como adicionar um README para o projeto.

README são arquivos geralmente em markdown (.md) para registrar a documentação do repositório com informações importantes como:

  • Nome

  • Descrição

  • Como usar

  • Etc

Criando README

# Criar e editar README
echo "# MilfsGo" > README.md
echo "Projeto para encontrar milfs na sua região" >> README.md

Adicionando ao Stage

# Adicionar arquivo específico
git add README.md

# Adicionar todos os arquivos
git add .

Verificando Status

git status

Version control system gitstatus
Version control system gitstatus
Resultado da execução do comando...

Commits

Anatomia de um Bom Commit

Padrões de Commit

# Commits semânticos
git commit -m "feat: adiciona sistema de busca"
git commit -m "fix: corrige bug no filtro de idade"
git commit -m "docs: atualiza documentação de instalação"

Branches

Fluxo de Branches

mainfeature/buscafeature/chat0-b7f9c8d1-f258b5c2-c1312ac4-1b09ada5-95fb511

Comandos de Branch

# Criar e mudar de branch
git checkout -b feature/nova-busca

# Listar branches
git branch

# Mudar de branch
git checkout main

# Deletar branch
git branch -d feature/antiga

Sincronização com Remoto

Configurando Remoto

# Adicionar remoto
git remote add origin https://github.com/user/MilfsGo.git

# Verificar remotos
git remote -v

Push e Pull

RemoteLocalRemoteLocalMantendo sincronizadogit pushgit pull
# Enviar alterações
git push origin main

# Buscar alterações
git pull origin main

Resolução de Conflitos

Tipos de Conflitos

<<<<<<< HEAD
Sua versão
=======
Versão remota
>>>>>>> branch-name

Resolvendo Conflitos

Abrir Arquivo

Escolher Versão

Marcar Resolvido

Finalizar

Conflito Detectado

Editar Conflito

Salvar

git add

git commit

Stash

Salvando Trabalho Temporário

# Guardar alterações
git stash

# Listar stashes
git stash list

# Recuperar alterações
git stash pop

Fluxo com Stash

BranchStashWorking DirBranchStashWorking Dirgit stashgit checkout othertrabalhogit stash pop

Tags

Versionamento

# Criar tag
git tag -a v1.0.0 -m "Primeira versão estável"

# Listar tags
git tag

# Publicar tags
git push origin --tags

Estrutura de Tags

TagsReleaseBetaRCv1.0.0v1.1.0v0.9.0-betav1.0.0-rc1

Logs e Histórico

Visualizando Histórico

# Log básico
git log

# Log formatado
git log --oneline --graph --decorate

# Log específico
git log --author="Stifler"

Buscando no Histórico

# Buscar por mensagem
git log --grep="feat"

# Buscar por conteúdo
git log -S "milf"

Melhores Práticas

Commits

Boas PráticasCommitsMensagensBranchesPequenosFocadosFrequentesClarasPadronizadasDescritivasOrganizadasTemporáriasDescritivas

Workflow Diário

📋 Daily Git Workflow

1. [ ] git pull origin main
2. [ ] git checkout -b feature/nova
3. [ ] Desenvolvimento
4. [ ] git add .
5. [ ] git commit -m "feat: nova função"
6. [ ] git push origin feature/nova
7. [ ] Criar Pull Request

Ferramentas Úteis

GUI Clients

Git GUIGitKrakenSourceTreeGitHub DesktopVisualIntuitivoGratuitoCompletoSimplesIntegrado

IDE Integration

  • VS Code

  • IntelliJ

  • Eclipse

  • Sublime

Dicas Avançadas

Aliases Úteis

# Configurar aliases
git config --global alias.st status
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit

Scripts de Produtividade

# Atualizar e limpar
git pull origin main && git remote prune origin

# Deletar branches mergeadas
git branch --merged | grep -v "\*" | xargs -n 1 git branch -d

Troubleshooting

Problemas Comuns

ProblemasConflitosCommitsRemoteMergeRebaseResetRevertPushPull

Soluções

🔧 Git Fixes

Commit errado:
└── git reset --soft HEAD^

Branch errada:
└── git checkout -b correct-branch

Conflito:
└── Resolver + git add + git commit

Próximos Passos

Avançando no Git

  1. Git Flow

  2. Rebase interativo

  3. Git Hooks

  4. CI/CD

Recursos Adicionais

Dica Pro: Mantenha um cheat sheet personalizado com seus comandos mais usados!

Comandos Essenciais do Git

Comandos por Situação

💩 Socorro! Fiz Besteira!

# Ops, commitei na branch errada
git reset HEAD~1            # Desfaz o último commit mantendo as alterações
git checkout branch-correta # Muda para a branch correta
git add .                   # Adiciona as alterações
git commit -m "feat: ..."   # Commit na branch certa

# Ops, commitei algo errado
git reset --soft HEAD~1     # Desfaz o commit mantendo alterações em stage
git reset --hard HEAD~1     # Desfaz o commit E as alterações (cuidado!)

# Ops, modifiquei o arquivo errado
git checkout -- arquivo.txt # Desfaz alterações não commitadas

# Ops, dei push em algo errado
git revert HEAD            # Cria novo commit desfazendo alterações
git push origin main      # Envia a reversão para o remoto

🆕 Começando um Projeto

# Iniciando do zero
git init
git add .
git commit -m "feat: commit inicial"

# Clonando projeto existente
git clone https://github.com/user/repo.git
git clone https://github.com/user/repo.git minha-pasta

📝 Trabalhando com Arquivos

# Básico
git add arquivo.txt        # Adiciona arquivo específico
git add .                  # Adiciona tudo
git rm arquivo.txt        # Remove arquivo
git mv antigo.txt novo.txt # Renomeia arquivo

# Ignorando arquivos
echo "*.log" >> .gitignore # Adiciona padrão ao .gitignore
echo "node_modules/" >> .gitignore # Ignora pasta

🌳 Branches

# Operações básicas
git branch                  # Lista branches
git branch nova-feature    # Cria branch
git checkout nova-feature  # Muda para branch
git checkout -b feature    # Cria e muda de branch

# Limpeza
git branch -d feature      # Deleta branch (se mergeada)
git branch -D feature      # Deleta branch (força)
git remote prune origin    # Remove branches remotas deletadas

🔄 Sincronização

# Com remoto
git remote add origin https://github.com/user/repo.git
git push -u origin main   # Primeiro push
git push                  # Pushes subsequentes
git pull                  # Atualiza do remoto

# Branches específicas
git push origin feature   # Envia branch específica
git pull origin feature   # Puxa branch específica

🔍 Investigação

# Status e logs
git status                # Estado atual
git log                   # Histórico de commits
git log --oneline        # Histórico resumido
git blame arquivo.txt    # Quem alterou cada linha

# Diferenças
git diff                  # Alterações não staged
git diff --staged        # Alterações staged
git diff branch1..branch2 # Entre branches

🤝 Merge e Rebase

# Merge
git checkout main         # Vai para branch destino
git merge feature         # Merge da feature

# Rebase
git checkout feature      # Vai para branch origem
git rebase main          # Rebase na main

# Conflitos
git merge --abort        # Cancela merge
git rebase --abort       # Cancela rebase

📌 Tags

# Criação
git tag v1.0.0                    # Tag leve
git tag -a v1.0.0 -m "Release 1.0.0" # Tag anotada

# Publicação
git push origin v1.0.0           # Envia tag específica
git push origin --tags           # Envia todas as tags

📦 Stash

# Guardando alterações
git stash                 # Guarda alterações
git stash save "WIP:..." # Guarda com descrição
git stash pop            # Recupera e remove
git stash apply          # Recupera e mantém
git stash list           # Lista stashes
git stash drop           # Remove stash

🎓 Comandos Avançados

Reescrevendo História

# Alterando commits
git commit --amend                # Altera último commit
git rebase -i HEAD~3             # Rebase interativo
git cherry-pick <commit-hash>    # Copia commit específico

# Limpeza
git clean -n                     # Lista arquivos a serem removidos
git clean -df                    # Remove arquivos não rastreados

Submodules

# Adicionando
git submodule add https://github.com/user/repo
git submodule update --init --recursive

# Atualizando
git submodule update --remote

Bisect

# Encontrando bugs
git bisect start
git bisect bad                   # Marca commit atual como ruim
git bisect good <commit-hash>    # Marca commit como bom
git bisect reset                # Finaliza busca

🛠️ Configurações Úteis

Aliases Produtivos

# Configurando aliases
git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
git config --global alias.unstage 'reset HEAD --'
git config --global alias.last 'log -1 HEAD'

Configurações Globais

# Identidade
git config --global user.name "Stifler"
git config --global user.email "stifler@milfsgo.com"

# Editor
git config --global core.editor "code --wait"

# Merge tool
git config --global merge.tool vscode

📊 Dicas de Performance

Repositórios Grandes

# Clone parcial
git clone --depth 1 https://github.com/user/repo.git

# Fetch específico
git fetch origin branch --depth 1

# Limpeza
git gc                    # Coleta de lixo
git prune                # Remove objetos órfãos

Otimizações

# Compressão
git gc --aggressive
git repack -ad

# Cache
git config --global core.preloadindex true
git config --global core.fscache true

🎯 Melhores Práticas

Commits Semânticos

git commit -m "feat: adiciona busca por localização"
git commit -m "fix: corrige bug no filtro de idade"
git commit -m "docs: atualiza README"
git commit -m "style: formata código"
git commit -m "refactor: simplifica função de busca"

Workflow Seguro

# Antes de começar
git pull origin main
git checkout -b feature

# Antes de commitar
git diff
git status
git add .
git commit -m "feat: ..."

# Antes de push
git pull --rebase origin main
git push origin feature

Dica Pro: Mantenha esse cheat sheet sempre à mão. Com o tempo você vai decorar os comandos mais usados, mas é sempre bom ter onde consultar!

Tabela Completa de Comandos

Comando Git

Descrição

Categoria

git init

Inicializa um novo repositório Git

🆕 Básico

git clone <url>

Clona um repositório existente

🆕 Básico

git clone <url> <pasta>

Clona para uma pasta específica

🆕 Básico

git clone --depth 1 <url>

Clona apenas o último commit (shallow clone)

🆕 Básico

git clone --bare <url>

Clona repositório sem working directory

🆕 Básico

git add <arquivo>

Adiciona arquivo ao stage

📝 Arquivos

git add .

Adiciona todos os arquivos ao stage

📝 Arquivos

git add -p

Adiciona alterações interativamente

📝 Arquivos

git add -u

Adiciona arquivos modificados e removidos

📝 Arquivos

git rm <arquivo>

Remove arquivo do repositório

📝 Arquivos

git rm --cached <arquivo>

Remove arquivo do stage mantendo local

📝 Arquivos

git mv <origem> <destino>

Move ou renomeia arquivo

📝 Arquivos

git commit -m "<mensagem>"

Cria um novo commit

📝 Básico

git commit -am "<mensagem>"

Adiciona modificações e commita

📝 Básico

git commit --amend

Modifica o último commit

🎓 Avançado

git commit --no-verify

Commit ignorando hooks

🎓 Avançado

git status

Mostra o estado atual do repositório

🔍 Investigação

git status -s

Mostra status em formato curto

🔍 Investigação

git log

Mostra histórico de commits

🔍 Investigação

git log --oneline

Mostra histórico resumido

🔍 Investigação

git log --graph

Mostra histórico com grafo

🔍 Investigação

git log --author="nome"

Filtra commits por autor

🔍 Investigação

git log --since="1 week ago"

Mostra commits da última semana

🔍 Investigação

git log -p

Mostra diferenças em cada commit

🔍 Investigação

git log --stat

Mostra estatísticas de alterações

🔍 Investigação

git blame <arquivo>

Mostra quem alterou cada linha

🔍 Investigação

git blame -L 10,20 <arquivo>

Blame de linhas específicas

🔍 Investigação

git diff

Mostra alterações não staged

🔍 Investigação

git diff --staged

Mostra alterações staged

🔍 Investigação

git diff HEAD

Mostra todas as alterações

🔍 Investigação

git diff --word-diff

Mostra diferenças por palavra

🔍 Investigação

git diff branch1..branch2

Compara duas branches

🔍 Investigação

git branch

Lista branches

🌳 Branches

git branch -r

Lista branches remotas

🌳 Branches

git branch -a

Lista todas as branches

🌳 Branches

git branch <nome>

Cria nova branch

🌳 Branches

git branch -m <novo-nome>

Renomeia branch atual

🌳 Branches

git branch --merged

Lista branches mergeadas

🌳 Branches

git branch --no-merged

Lista branches não mergeadas

🌳 Branches

git checkout <branch>

Muda para outra branch

🌳 Branches

git checkout -

Volta para branch anterior

🌳 Branches

git checkout -b <branch>

Cria e muda para nova branch

🌳 Branches

git checkout -- <arquivo>

Descarta alterações em arquivo

🌳 Branches

git checkout HEAD~1

Vai para commit anterior

🌳 Branches

git switch <branch>

Muda para branch (Git moderno)

🌳 Branches

git switch -c <branch>

Cria e muda branch (Git moderno)

🌳 Branches

git branch -d <branch>

Deleta branch (se mergeada)

🌳 Branches

git branch -D <branch>

Força deleção de branch

🌳 Branches

git merge <branch>

Faz merge de uma branch

🤝 Merge/Rebase

git merge --no-ff <branch>

Merge criando commit mesmo se fast-forward

🤝 Merge/Rebase

git merge --squash <branch>

Merge combinando commits

🤝 Merge/Rebase

git rebase <branch>

Faz rebase em uma branch

🤝 Merge/Rebase

git rebase -i <commit>

Rebase interativo desde commit

🤝 Merge/Rebase

git rebase --onto <base> <old> <new>

Rebase específico

🤝 Merge/Rebase

git merge --abort

Cancela merge em andamento

🤝 Merge/Rebase

git rebase --abort

Cancela rebase em andamento

🤝 Merge/Rebase

git remote add <nome> <url>

Adiciona repositório remoto

🔄 Sincronização

git remote -v

Lista repositórios remotos

🔄 Sincronização

git remote show <nome>

Mostra informações do remoto

🔄 Sincronização

git remote rename <old> <new>

Renomeia remoto

🔄 Sincronização

git remote remove <nome>

Remove remoto

🔄 Sincronização

git push

Envia commits para remoto

🔄 Sincronização

git push -u origin <branch>

Push configurando upstream

🔄 Sincronização

git push --force

Força push (cuidado!)

🔄 Sincronização

git push --force-with-lease

Force push mais seguro

🔄 Sincronização

git pull

Atualiza do repositório remoto

🔄 Sincronização

git pull --rebase

Pull usando rebase

🔄 Sincronização

git fetch

Busca atualizações do remoto

🔄 Sincronização

git fetch --all

Busca de todos os remotos

🔄 Sincronização

git fetch --prune

Fetch removendo refs obsoletas

🔄 Sincronização

git tag <nome>

Cria tag leve

📌 Tags

git tag -a <nome> -m "<msg>"

Cria tag anotada

📌 Tags

git tag -l "v1.*"

Lista tags com padrão

📌 Tags

git tag -d <nome>

Remove tag local

📌 Tags

git push origin <tag>

Envia tag específica

📌 Tags

git push origin --tags

Envia todas as tags

📌 Tags

git push origin :refs/tags/<tag>

Remove tag remota

📌 Tags

git stash

Guarda alterações temporariamente

📦 Stash

git stash save "mensagem"

Stash com descrição

📦 Stash

git stash push -m "mensagem"

Stash moderno com mensagem

📦 Stash

git stash --keep-index

Stash mantendo staging

📦 Stash

git stash --include-untracked

Stash incluindo novos arquivos

📦 Stash

git stash pop

Recupera e remove stash

📦 Stash

git stash apply

Recupera mantendo stash

📦 Stash

git stash list

Lista stashes salvos

📦 Stash

git stash show

Mostra alterações do stash

📦 Stash

git stash drop

Remove stash

📦 Stash

git stash clear

Remove todos os stashes

📦 Stash

git stash branch <nome>

Cria branch do stash

📦 Stash

git reset HEAD~1

Desfaz último commit mantendo alterações

💩 Correções

git reset --soft HEAD~1

Desfaz commit mantendo stage

💩 Correções

git reset --hard HEAD~1

Desfaz commit e alterações

💩 Correções

git reset --mixed HEAD~1

Reset padrão

💩 Correções

git reset <arquivo>

Remove arquivo do stage

💩 Correções

git revert HEAD

Cria commit que desfaz alterações

💩 Correções

git revert -m 1 <commit>

Reverte merge commit

💩 Correções

git clean -n

Lista arquivos a serem removidos

🎓 Avançado

git clean -df

Remove arquivos não rastreados

🎓 Avançado

git clean -xdf

Remove arquivos ignorados também

🎓 Avançado

git cherry-pick <commit>

Copia commit específico

🎓 Avançado

git cherry-pick -x <commit>

Cherry-pick com referência

🎓 Avançado

git rebase -i HEAD~n

Rebase interativo

🎓 Avançado

git submodule add <url>

Adiciona submódulo

🎓 Avançado

git submodule update --init

Inicializa submódulos

🎓 Avançado

git submodule update --recursive

Atualiza submódulos recursivamente

🎓 Avançado

git worktree add <path> <branch>

Cria worktree

🎓 Avançado

git worktree list

Lista worktrees

🎓 Avançado

git bisect start

Inicia busca binária

🎓 Avançado

git bisect good/bad

Marca commit como bom/ruim

🎓 Avançado

git bisect reset

Finaliza bisect

🎓 Avançado

git gc

Executa coleta de lixo

📊 Performance

git gc --aggressive

Otimização mais agressiva

📊 Performance

git prune

Remove objetos órfãos

📊 Performance

git fsck

Verifica integridade do repositório

📊 Performance

git count-objects -v

Conta objetos do repositório

📊 Performance

git config --global

Define configurações globais

🛠️ Configuração

git config --local

Define configurações do repo

🛠️ Configuração

git config --list

Lista todas configurações

🛠️ Configuração

git config --edit

Edita configurações no editor

🛠️ Configuração

git remote prune origin

Remove branches remotas deletadas

🧹 Limpeza

git reflog

Mostra histórico de referências

🔍 Investigação

git reflog expire --expire=now --all

Limpa reflog

🧹 Limpeza

git maintenance start

Inicia manutenção automática

📊 Performance

git verify-pack -v .git/objects/pack/pack-*.idx

Analisa objetos empacotados

📊 Performance

git rev-parse HEAD

Mostra hash do commit atual

🔍 Investigação

git rev-list --count HEAD

Conta número de commits

🔍 Investigação

git shortlog

Resumo de commits por autor

🔍 Investigação

git describe

Descreve commit usando tags

🔍 Investigação

git archive

Cria arquivo do repositório

📦 Arquivamento

git bundle create repo.bundle HEAD

Cria bundle do repositório

📦 Arquivamento

git notes add -m "nota" <commit>

Adiciona nota a commit

📝 Notas

git grep "termo"

Busca termo no código

🔍 Investigação

git show <commit>

Mostra informações do commit

🔍 Investigação

git show-branch

Mostra branches e seus commits

🔍 Investigação

git whatchanged

Mostra histórico de mudanças

🔍 Investigação

git log --graph --oneline

Mostra log em formato de árvore

🔍 Investigação

git log --author="nome"

Filtra commits por autor

🔍 Investigação

git log --since="1 week ago"

Mostra commits da última semana

🔍 Investigação

git log --grep="feat"

Busca commits por mensagem

🔍 Investigação

git log -p <arquivo>

Mostra histórico de mudanças do arquivo

🔍 Investigação

git blame -L 10,20 <arquivo>

Mostra autores das linhas 10-20

🔍 Investigação

git diff --cached

Mostra diferenças staged

🔍 Investigação

git diff branch1...branch2

Compara branches desde ancestral comum

🔍 Investigação

git checkout -

Volta para branch anterior

🌳 Branches

git branch --merged

Lista branches já mergeadas

🌳 Branches

git branch --no-merged

Lista branches não mergeadas

🌳 Branches

git push --delete origin <branch>

Remove branch remota

🌳 Branches

git commit --amend --no-edit

Adiciona alterações ao último commit

💩 Correções

git restore --staged <arquivo>

Remove arquivo do stage (Git moderno)

💩 Correções

git restore <arquivo>

Descarta alterações não staged (Git moderno)

💩 Correções

git rebase --onto main topic-1 topic-2

Rebases encadeados

🎓 Avançado

git merge-base branch1 branch2

Encontra commit ancestral comum

🎓 Avançado

git rev-parse --short HEAD

Mostra hash curto do commit atual

🔍 Investigação

git update-index --skip-worktree <arquivo>

Ignora mudanças locais

🛠️ Configuração

git update-index --no-skip-worktree <arquivo>

Volta a rastrear mudanças

🛠️ Configuração

Dica Pro: Use git help <comando> para ver a documentação completa de qualquer comando!

Git Internals: Como o Git Funciona por Dentro

+------------------------+
|       Git Object       |
|        Storage        |
|                       |
|   +---------------+   |
|   |    Commit    |   |
|   |   +-Tree-+   |   |
|   |   |Blob  |   |   |
|   |   |Blob  |   |   |
|   |   +------+   |   |
|   +---------------+   |
|                       |
|   .git/              |
|   ├── objects/       |
|   ├── refs/         |
|   └── HEAD          |
+------------------------+

Sistema de Objetos do Git

Tipos de Objetos

Objetos GitBlobTreeCommitTagConteúdoSHA-1DiretóriosPermissõesMetadadosSnapshotAnotadaLeve

Como os Objetos se Relacionam

Aponta para

Contém

Subdiretório

Arquivo

Parent

Commit

Tree

Blob

Tree

Blob

Commit Anterior

Anatomia de um Commit

Estrutura Básica

commit 1fc408bfdb92... 
tree a906cb2a4a904...
parent 83bc0145a898...
author Stifler <stifler@milfsgo.com> 1625097600 -0300
committer Stifler <stifler@milfsgo.com> 1625097600 -0300

feat: adiciona sistema de busca de milfs

Composição do SHA-1

Hash

Hash

Hash

Metadata

SHA-1

Content

Parent

Sistema de Referências

Referencias Principais

RefsHEADBranchTagRemoteCurrentDetachedLocalRemoteLightweightAnnotatedOriginUpstream

Como o HEAD Funciona

Aponta para

Aponta para

Detached

HEAD

Branch

Commit

Armazenamento de Objetos

Estrutura do .git

.git/
├── objects/
│   ├── pack/
│   ├── info/
│   ├── aa/
│   └── bb/
├── refs/
│   ├── heads/
│   ├── tags/
│   └── remotes/
├── HEAD
└── config

Processo de Compressão

git gc

Delta

Objetos Soltos

Packfile

Comprimido

Como o Git Armazena Mudanças

Snapshot vs Delta

Git

Snapshot 1

Snapshot 2

Snapshot 3

Outros VCS

Delta

Delta

V1

V2

V3

Processo de Staging

RepositoryStagingWorking DirRepositoryStagingWorking DirCria objetosCria commitgit addgit commit

Garbage Collection

O que é Coletado

  • Objetos não referenciados

  • Objetos soltos antigos

  • Referências dangling

  • Packfiles redundantes

Quando Acontece

git gc

Threshold

Server

Manual

GC

Auto

Push

Dicas de Performance

Otimizações

  1. Clones rasos

  2. Sparse checkout

  3. Partial clone

  4. Prune regular

Monitoramento

Size

Health

Optimize

git count-objects

Disk Usage

git fsck

Repository

git gc --aggressive

Performance

Comandos para Exploração

Comandos Úteis

# Ver objeto
git cat-file -p SHA1

# Listar referências
git show-ref

# Ver árvore
git ls-tree HEAD

# Contar objetos
git count-objects -v

# Verificar integridade
git fsck

Considerações de Segurança

Proteção de Dados

SegurançaHashRefsObjectsSHA-1CollisionProtectedSignedImmutableVerified

Próximos Passos

Tópicos Avançados

Dica: Entender os internals do Git ajuda muito na resolução de problemas e na otimização do uso da ferramenta.

Objetos Git: Os Blocos Fundamentais

+------------------+
|    Git Object    |
|    Database      |
|                  |
|  SHA-1 -> Data   |
|                  |
|  Type + Size     |
|  + Content       |
+------------------+

Tipos de Objetos

1. Blob (Binary Large Object)

+-------------+
|    BLOB     |
+-------------+
| • Conteúdo  |
| • SHA-1     |
| • Tamanho   |
+-------------+

Exemplo de estrutura interna:

blob 42\0Hello, World!

2. Tree (Árvore)

+----------------+
|     TREE      |
+----------------+
| 100644 blob K1|
| 100755 blob K2|
| 040000 tree K3|
+----------------+

Exemplo de estrutura:

$ git cat-file -p master^{tree}
100644 blob a906cb2a4a904... README.md
100644 blob 8ab686eafeb5... index.js
040000 tree ab8763f6e1dd... src

3. Commit

+------------------+
|     COMMIT       |
+------------------+
| • Tree          |
| • Parent(s)     |
| • Author        |
| • Committer     |
| • Message       |
+------------------+

Exemplo de estrutura:

tree a906cb2a4a904...
parent 83bc0145a898...
author Dev <dev@example.com> 1625097600 -0300
committer Dev <dev@example.com> 1625097600 -0300

Initial commit

4. Tag

+------------------+
|       TAG        |
+------------------+
| • Object        |
| • Type          |
| • Tag Name      |
| • Tagger        |
| • Message       |
+------------------+

Como os Objetos São Armazenados

Estrutura do Diretório

.git/objects/
├── pack/
│   ├── pack-*.pack
│   └── pack-*.idx
├── info/
└── xx/
    └── yyyyyyyyyy...

Processo de Hash

SHA-1

Primeiros 2 chars

Restante

Conteúdo

Hash

Diretório

Nome do Arquivo

Manipulando Objetos

Comandos Essenciais

# Criar blob
echo 'test content' | git hash-object -w --stdin

# Ver conteúdo
git cat-file -p <hash>

# Ver tipo
git cat-file -t <hash>

# Ver tamanho
git cat-file -s <hash>

Relacionamentos Entre Objetos

Aponta para

Tree

Blob

Tree

Blob

Tag

Commit

Root Tree

arquivo1.txt

diretório

arquivo2.txt

Integridade dos Objetos

Garantias do Sistema

Compressão e Performance

Estratégias de Otimização

  1. Zlib compression

  2. Delta encoding

  3. Packfiles

  4. Garbage collection

Exemplo de Delta

Base object: "Hello World"
Delta: @@ -1,5 +1,6 @@
       Hello
      +New
       World

Dicas Práticas

Debug e Inspeção

# Listar todos objetos
git rev-list --objects --all

# Encontrar objetos grandes
git verify-pack -v .git/objects/pack/*.idx

# Inspecionar packfile
git unpack-objects -n < .git/objects/pack/*.pack

Boas Práticas

  1. Evite arquivos grandes

  2. Use Git LFS quando necessário

  3. Execute gc regularmente

  4. Monitore o tamanho do repositório

Troubleshooting

Problemas Comuns

ProblemasCorrupçãoPerformanceEspaçoVerificarRepararCompactarOtimizarLimparComprimir

Próximos Passos

Tópicos Relacionados

Dica Pro: Use git count-objects -v regularmente para monitorar o crescimento do seu repositório.

Referências Git: Navegando pelo Histórico

+------------------------+
|     Git References     |
|                        |
|    HEAD -> main        |
|    main -> a1b2c3      |
|    feature -> d4e5f6   |
|    v1.0 -> 789abc      |
|                        |
|    .git/refs/          |
+------------------------+

Tipos de Referências

1. HEAD

+-------------+
|    HEAD     |
+-------------+
| • Symbolic  |
| • Detached  |
| • Current   |
+-------------+

Exemplo de .git/HEAD:

ref: refs/heads/main

2. Branches (refs/heads/)

+------------------+
|     BRANCH      |
+------------------+
| • Local         |
| • Remote-track  |
| • Lightweight   |
+------------------+

Estrutura típica:

.git/refs/heads/
├── main
├── develop
└── feature/
    └── new-feature

3. Tags (refs/tags/)

+------------------+
|      TAG        |
+------------------+
| • Lightweight   |
| • Annotated     |
| • Signed        |
+------------------+

Sistema de Referências

Anatomia de uma Referência

Aponta para

Parent

Symbolic Ref

Direct Ref

Referência

Commit

Commit Anterior

HEAD

Branch

Namespace Hierárquico

.git/
├── refs/
│   ├── heads/
│   ├── tags/
│   ├── remotes/
│   └── stash
└── HEAD

Manipulando Referências

Comandos Essenciais

# Listar referências
git show-ref

# Ver para onde HEAD aponta
git symbolic-ref HEAD

# Criar branch
git update-ref refs/heads/nova-branch HEAD

# Criar tag
git update-ref refs/tags/v1.0 HEAD

Referências Especiais

1. FETCH_HEAD

+------------------+
|   FETCH_HEAD    |
+------------------+
| Último fetch    |
| de cada branch  |
+------------------+

2. ORIG_HEAD

+------------------+
|   ORIG_HEAD     |
+------------------+
| Backup antes de |
| operações       |
| perigosas       |
+------------------+

3. MERGE_HEAD

+------------------+
|   MERGE_HEAD    |
+------------------+
| Branch sendo    |
| mergada         |
+------------------+

Referências Relativas

Navegação no Histórico

^

^

~3

HEAD

Parent

Grandparent

3 commits atrás

Exemplos Práticos

HEAD^      # Parent do HEAD
HEAD~2     # Dois commits atrás
main^2     # Segundo parent (em merges)
HEAD@{1}   # Posição anterior no reflog

Reflog: Histórico de Referências

Estrutura do Reflog

+------------------+
|     REFLOG      |
+------------------+
| HEAD@{0}        |
| HEAD@{1}        |
| HEAD@{2}        |
+------------------+

Comandos de Reflog

# Ver histórico
git reflog

# Ver reflog específico
git reflog show main

# Expirar entradas antigas
git reflog expire --expire=30.days.ago

Boas Práticas

Organização

Manutenção

  1. Limpe branches obsoletas

  2. Use tags para releases

  3. Mantenha reflog limpo

  4. Documente convenções

Troubleshooting

Problemas Comuns

+----------------------+
|     Problemas        |
|                      |
| • HEAD desanexado    |
| • Ref corrompida     |
| • Conflito de nomes  |
| • Refs perdidas      |
+----------------------+

Soluções

# Reparar referências
git fsck --full

# Recriar referência
git update-ref -d refs/heads/broken
git branch broken HEAD

# Recuperar commit perdido
git fsck --lost-found

Próximos Passos

Tópicos Relacionados

Dica Pro: Use git show-ref --heads --tags para uma visão rápida de todas as suas referências importantes.

Git Packfiles: Otimizando o Armazenamento

+------------------------+
|       Packfile         |
|                        |
| Objects + Index        |
| Delta Compression      |
| Network Transfer       |
|                        |
| .git/objects/pack/    |
+------------------------+

Estrutura dos Packfiles

Componentes Principais

+------------------+
|    PACKFILE     |
+------------------+
| • Header        |
| • Objects       |
| • Deltas        |
| • Index         |
+------------------+

Formato do Arquivo

pack-<SHA-1>.pack
pack-<SHA-1>.idx

Compressão Delta

Como Funciona

Delta

Delta

Delta

Objeto Base

Objeto 1

Objeto 2

Objeto 3

Tipos de Delta

+-----------------+
|  DELTA TYPES    |
+-----------------+
| • REF_DELTA    |
| • OFS_DELTA    |
+-----------------+

Criação de Packfiles

Processo Automático

Git GCPackfileLoose ObjectsGit GCPackfileLoose ObjectsThreshold atingidoCriar packfileRemover objetos soltos

Comandos Manuais

# Criar packfile
git gc

# Repack otimizado
git repack -ad

# Verificar packfiles
git verify-pack -v .git/objects/pack/*.idx

Otimização de Performance

Estratégias

  1. Delta compression

  2. Object reuse

  3. Network transfer

  4. Index optimization

Configurações

# Ajustar compressão
git config pack.compression 9

# Limite de window
git config pack.windowMemory "100m"

# Delta cache size
git config core.deltaBaseCacheLimit "1g"

Rede e Transferência

Protocolo de Transferência

ServerClientServerClientwant <SHA-1>pack dataunpack

Otimizações de Rede

+------------------+
| TRANSFER OPT     |
+------------------+
| • Thin pack     |
| • Multi-pack    |
| • Smart proto   |
+------------------+

Manutenção

Rotinas de Manutenção

ManutençãoRepackPruneVerifyRegularOtimizadoObjetos soltosPackfiles antigosIntegridadeConsistência

Comandos de Manutenção

# Repack total
git repack -a -d -f --window=250 --depth=250

# Verificar packfiles
git fsck --full

# Limpar objetos
git prune-packed

Troubleshooting

Problemas Comuns

+----------------------+
|      PROBLEMAS       |
|                      |
| • Packfile corrupto  |
| • Delta muito grande |
| • Memória insuf.     |
| • Fragmentação       |
+----------------------+

Diagnóstico

# Listar objetos grandes
git verify-pack -v .git/objects/pack/*.idx | sort -k 3 -n

# Verificar integridade
git fsck --full

# Estatísticas
git count-objects -v

Boas Práticas

Recomendações

  1. Repack periódico

  2. Monitorar tamanho

  3. Backup antes de repack

  4. Verificar integridade

Configurações Recomendadas

# Para repositórios grandes
git config pack.deltaCacheSize 1g
git config pack.windowMemory 1g
git config pack.threads 4

Ferramentas e Scripts

Utilitários Úteis

# Análise de packfile
git show-index < .git/objects/pack/*.idx

# Extrair objeto
git unpack-objects < .git/objects/pack/*.pack

# Estatísticas detalhadas
git count-objects --verbose

Próximos Passos

Tópicos Relacionados

Dica Pro: Use git gc --aggressive com cautela - é mais intensivo em CPU e nem sempre necessário para repositórios menores.

Git Garbage Collection: Mantendo o Repositório Otimizado

+------------------------+
|   Garbage Collection   |
|                        |
| Cleanup + Optimization |
| Pack + Compress        |
| Maintain Performance   |
|                        |
| git gc                 |
+------------------------+

Como Funciona

Processo Básico

Empacotamento

Limpeza

Remoção

Objetos Soltos

Packfiles

Refs Antigas

Refs Atuais

Objetos Órfãos

Objetos Referenciados

Gatilhos Automáticos

+------------------+
|    TRIGGERS     |
+------------------+
| • Push          |
| • Fetch         |
| • Merge         |
| • Threshold     |
+------------------+

O que é Coletado

Tipos de Objetos

GCObjetosRefsPackfilesUnreachableDanglingObsoletasQuebradasRedundantesAntigos

Processo de Coleta

ReferenciasPackfilesLoose ObjectsReferenciasPackfilesLoose ObjectsCompactaçãoLimpezaOtimização

Comandos Principais

Comandos Básicos

# GC básico
git gc

# GC agressivo
git gc --aggressive

# GC automático
git gc --auto

# Prune
git prune

Configurações

# Ajustar threshold
git config gc.auto 256

# Frequência de auto-gc
git config gc.autoPackLimit 50

# Expiração de objetos
git config gc.pruneExpire "2.weeks.ago"

Otimização de Performance

Estratégias

+----------------------+
|    OTIMIZAÇÕES      |
|                     |
| • Delta compression |
| • Repack            |
| • Prune             |
| • Reflog expire     |
+----------------------+

Comandos Avançados

# Repack otimizado
git repack -ad

# Expirar reflog
git reflog expire --expire=now --all

# Verificar objetos
git fsck --full

# Estatísticas
git count-objects -v

Manutenção Programada

Rotina de Manutenção

fsck

repack

Verificação

Verificação

GC

Prune

Agendamento

# Iniciar manutenção
git maintenance start

# Configurar agenda
git maintenance register

# Executar agora
git maintenance run --task=gc

Troubleshooting

Problemas Comuns

+----------------------+
|      PROBLEMAS      |
|                     |
| • GC muito lento    |
| • Espaço em disco   |
| • Objetos perdidos  |
| • Performance       |
+----------------------+

Diagnóstico

# Verificar objetos
git fsck --unreachable

# Analisar packfiles
git verify-pack -v .git/objects/pack/*.idx

# Encontrar objetos grandes
git rev-list --objects --all | git cat-file --batch-check

Boas Práticas

Recomendações

  1. GC regular

  2. Backup antes de GC agressivo

  3. Monitorar tamanho

  4. Verificar integridade

Configurações Recomendadas

# Para repos grandes
git config gc.auto 1024
git config gc.autoPackLimit 100
git config gc.pruneExpire "1.month.ago"

Monitoramento

Métricas Importantes

MétricasTamanhoObjetosPerformanceRepositórioPackfilesSoltosEmpacotadosCloneFetch

Comandos de Monitoramento

# Estatísticas detalhadas
git count-objects --verbose

# Tamanho dos packfiles
du -sh .git/objects/pack/

# Objetos grandes
git verify-pack -v .git/objects/pack/*.idx | sort -k 3 -n | tail -10

Próximos Passos

Tópicos Relacionados

Dica Pro: Configure git maintenance para automatizar a manutenção do repositório e manter a performance consistente.

Git Avançado: Recursos e Técnicas Poderosas

+------------------------+
|    Git Avançado       |
|                       |
| Hooks + Submodules    |
| Worktrees + Bisect    |
| Filter-branch + LFS   |
|                       |
| Power User Features   |
+------------------------+

Recursos Avançados

Visão Geral

Git AvançadoHooksSubmodulesWorktreesBisectFilter-branchPre-commitPost-receiveNestedUpdatesMultipleLinkedDebugSearchRewriteClean

Git Hooks

Tipos Principais

+------------------+
|     HOOKS       |
+------------------+
| • pre-commit    |
| • post-commit   |
| • pre-push      |
| • post-receive  |
+------------------+

Exemplos Práticos

# Hook de qualidade de código
#!/bin/sh
./lint.sh
./test.sh

# Hook de mensagem de commit
#!/bin/sh
commit_msg=$(cat "$1")
if ! echo "$commit_msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore):"; then
    echo "Erro: Mensagem não segue convenção"
    exit 1
fi

Submodules e Subtrees

Gerenciamento

Submodule

Submodule

Subtree

Projeto Principal

Repo A

Repo B

Repo C

Comandos Essenciais

# Submodules
git submodule add <repo>
git submodule update --init --recursive

# Subtrees
git subtree add --prefix=lib <repo> master
git subtree pull --prefix=lib <repo> master

Worktrees

Uso Múltiplo

+------------------+
|   WORKTREES     |
+------------------+
| main  → /main   |
| feat  → /feat   |
| hotfix → /fix   |
+------------------+

Comandos Básicos

# Criar worktree
git worktree add ../feat feature-branch

# Listar worktrees
git worktree list

# Remover worktree
git worktree remove ../feat

Git Bisect

Processo de Debug

Uso Prático

# Iniciar bisect
git bisect start
git bisect bad HEAD
git bisect good v1.0

# Automatizar
git bisect run ./test.sh

Filter-branch

Casos de Uso

Filter-branchLimparReorganizarCorrigirArquivos grandesDados sensíveisSubdiretóriosHistóricoAutorEmail

Exemplos

# Remover arquivo do histórico
git filter-branch --tree-filter 'rm -f senha.txt' HEAD

# Alterar email
git filter-branch --commit-filter '
    if [ "$GIT_AUTHOR_EMAIL" = "old@email.com" ];
    then
        GIT_AUTHOR_EMAIL="new@email.com";
        git commit-tree "$@";
    else
        git commit-tree "$@";
    fi' HEAD

Git LFS

Configuração

+------------------+
|    Git LFS      |
+------------------+
| • Track files   |
| • Push/Pull     |
| • Migrate       |
+------------------+

Comandos LFS

# Iniciar LFS
git lfs install

# Rastrear arquivos
git lfs track "*.psd"

# Status
git lfs status

Otimizações Avançadas

Técnicas

Config

Storage

Network

Index

Performance

Core

Pack

Transfer

Cache

Configurações

# Performance
git config core.preloadindex true
git config core.fsmonitor true
git config gc.auto 256

Segurança Avançada

Práticas

+------------------+
|   SEGURANÇA     |
+------------------+
| • GPG signing   |
| • SSH keys      |
| • Hooks sec     |
| • Audit log     |
+------------------+

Configurações

# Assinar commits
git config commit.gpgsign true

# Verificar objetos
git config transfer.fsckObjects true

Troubleshooting Avançado

Ferramentas

DebugTraceFSckReflogGIT_TRACEGIT_CURL_VERBOSEIntegridadeCorrupçãoRecuperaçãoHistória

Comandos Debug

# Debug detalhado
GIT_TRACE=1 git pull origin main

# Verificar repo
git fsck --full

# Ver reflog
git reflog expire --expire=now --all

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um ambiente de teste para experimentar recursos avançados antes de aplicá-los em projetos reais.

Git Hooks: Automatizando seu Workflow

+------------------------+
|       Git Hooks        |
|                        |
| Client + Server Hooks  |
| Automation + Quality   |
| Custom Scripts         |
|                        |
| .git/hooks            |
+------------------------+

Tipos de Hooks

Client-side Hooks

Antes do commit

Mensagem

Após commit

Antes do push

Pre-commit

Validação

Prepare-commit-msg

Template

Post-commit

Notificação

Pre-push

Testes

Server-side Hooks

Antes do receive

Durante receive

Após receive

Pre-receive

Validação

Update

Branch Policy

Post-receive

Deploy/CI

Hooks Comuns

Pre-commit

#!/bin/sh
# Verificar estilo de código
./lint.sh

# Rodar testes unitários
./test.sh

# Verificar secrets
./check-secrets.sh

exit 0

Prepare-commit-msg

#!/bin/sh
# Adicionar número do ticket
TICKET=$(git branch | grep '*' | sed 's/* //' | grep -o 'PROJ-[0-9]\+')
echo "$TICKET: $(cat $1)" > $1

Pre-push

#!/bin/sh
# Executar testes
npm test

# Verificar build
npm run build

# Validar cobertura
npm run coverage

Implementação

Estrutura de Diretórios

.git/
└── hooks/
    ├── pre-commit
    ├── prepare-commit-msg
    ├── post-commit
    ├── pre-push
    └── post-receive

Ativação de Hooks

# Tornar hook executável
chmod +x .git/hooks/pre-commit

# Criar link simbólico
ln -s ../../scripts/pre-commit.sh .git/hooks/pre-commit

Hooks Avançados

Integração com Ferramentas

HooksLintingTestesCI/CDQualidadeESLintPrettierJestMochaJenkinsGitHub ActionsSonarQubeCodeClimate

Scripts Complexos

#!/bin/sh
# Hook multi-etapa
set -e

echo "🔍 Verificando código..."
npm run lint

echo "🧪 Executando testes..."
npm test

echo "📦 Verificando build..."
npm run build

echo "✨ Tudo pronto!"

Boas Práticas

Recomendações

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Scripts modulares   |
| • Logs claros        |
| • Timeouts           |
| • Fallbacks          |
| • Configurável       |
+------------------------+

Configuração

# Config global de hooks
git config core.hooksPath .githooks

# Skip hooks quando necessário
git commit --no-verify

Compartilhamento

Versionamento

Commit

Install

Symlink

Hooks

.githooks/

Script

.git/hooks

Script de Instalação

#!/bin/sh
# install-hooks.sh
HOOK_DIR=.git/hooks
CUSTOM_HOOK_DIR=.githooks

for hook in $CUSTOM_HOOK_DIR/*; do
    ln -sf "../../$hook" "$HOOK_DIR/$(basename $hook)"
done

Troubleshooting

Problemas Comuns

+------------------------+
|      PROBLEMAS        |
|                       |
| • Permissões         |
| • Path errado        |
| • Dependências       |
| • Performance        |
+------------------------+

Debug

# Debug de hooks
GIT_TRACE=1 git commit -m "test"

# Verificar permissões
ls -l .git/hooks/

# Testar hook manualmente
.git/hooks/pre-commit

Exemplos Práticos

Validação de Código

#!/bin/sh
# pre-commit
FILES=$(git diff --cached --name-only --diff-filter=ACM | grep '\.js$')
[ -z "$FILES" ] && exit 0

# Lint
echo "🔍 Verificando arquivos JS..."
./node_modules/.bin/eslint $FILES

Conventional Commits

#!/bin/sh
# prepare-commit-msg
commit_msg=$(cat $1)
if ! echo "$commit_msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore):"; then
    echo "❌ Erro: Mensagem deve seguir Conventional Commits"
    echo "✨ Exemplo: feat: adiciona novo recurso"
    exit 1
fi

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha seus hooks em um repositório separado e use um sistema de gerenciamento como Husky para facilitar a manutenção e distribuição.

Git Submodules: Gerenciando Dependências como Submódulos

+------------------------+
|     Git Submodules    |
|                       |
| Nested Repositories   |
| Dependency Management |
| Version Control       |
|                       |
| Project Integration   |
+------------------------+

Conceitos Básicos

O que são Submodules?

Contém

Contém

Referencia

Referencia

Projeto Principal

Submodule A

Submodule B

Commit Específico

Commit Específico

Estrutura

projeto/
├── .git/
├── .gitmodules
├── lib/
│   └── dependency/
└── src/

Comandos Essenciais

Operações Básicas

# Adicionar submodule
git submodule add https://github.com/user/repo lib/repo

# Inicializar submodules
git submodule init

# Atualizar submodules
git submodule update --init --recursive

# Remover submodule
git submodule deinit lib/repo
git rm lib/repo

Clonagem

# Clone com submodules
git clone --recursive https://github.com/user/repo

# Ou após clone normal
git submodule update --init --recursive

Gerenciamento

Atualizando Submodules

SubmoduleMain RepoSubmoduleMain Repogit submodule updateCheckout commitAtualiza referência

Trabalhando com Branches

# Entrar no submodule
cd lib/repo

# Mudar branch
git checkout main

# Atualizar
git pull origin main

# Voltar e commitar
cd ../..
git add lib/repo
git commit -m "atualiza submodule"

Boas Práticas

Recomendações

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Versões estáveis   |
| • Commits atômicos   |
| • Documentação clara |
| • Updates planejados |
| • Testes integrados  |
+------------------------+

Configuração

# Configurar push recursivo
git config push.recurseSubmodules on-demand

# Configurar status detalhado
git config status.submoduleSummary true

Troubleshooting

Problemas Comuns

ProblemasDetached HEADUpdates falhamConflitosCheckout branchUpdate referenceNetwork issuesPermissionsWrong URLsMergeRebaseReset

Soluções

# Resolver detached HEAD
cd submodule
git checkout main
cd ..
git add submodule
git commit

# Forçar update
git submodule update --force --recursive

Workflows

Desenvolvimento

Update

Test

Commit

Push

Develop

Submodule

Integration

Main Repo

Remote

CI/CD

# Script de CI
#!/bin/sh
# Inicializar e atualizar submodules
git submodule update --init --recursive

# Build e teste
for module in $(git submodule | awk '{print $2}'); do
    cd $module
    npm install
    npm test
    cd ..
done

Alternativas

Comparação

DependencySubmodulesPackage ManagerMonorepoGit nativeVersion controlComplex setupnpm/yarncomposerSimple setupAll in oneSimple workflowLarge size

Dicas Avançadas

Performance

# Clone superficial
git clone --depth 1 --shallow-submodules

# Update paralelo
git submodule update --init --recursive --jobs 4

Automação

# Hook pre-push
#!/bin/sh
git submodule foreach git push

# Hook post-merge
#!/bin/sh
git submodule update --recursive

Próximos Passos

Tópicos Relacionados

Dica Pro: Use git submodule foreach para executar comandos em todos os submódulos de uma vez. Por exemplo: git submodule foreach git pull origin main

Git Subtrees: Alternativa Flexível aos Submódulos

+------------------------+
|     Git Subtrees      |
|                       |
| Project Integration   |
| Code Sharing          |
| History Preservation  |
|                       |
| Flexible Management   |
+------------------------+

Conceitos Básicos

O que são Subtrees?

Incorpora

Com

Mantém

Com

Projeto Principal

Código Fonte

Histórico Completo

Independência

Updates Controlados

Estrutura

projeto/
├── .git/
├── src/
└── lib/
    └── external/
        └── [código incorporado]

Comandos Essenciais

Operações Básicas

# Adicionar subtree
git subtree add --prefix=lib/demo https://github.com/user/demo main --squash

# Atualizar subtree
git subtree pull --prefix=lib/demo https://github.com/user/demo main --squash

# Enviar mudanças
git subtree push --prefix=lib/demo https://github.com/user/demo main

Split e Merge

# Extrair subtree como branch
git subtree split --prefix=lib/demo -b temp_branch

# Mesclar mudanças
git subtree merge --prefix=lib/demo temp_branch

Gerenciamento

Fluxo de Trabalho

SubtreeMain ProjectSubtreeMain Projectgit subtree addDevelopmentgit subtree pushUpdatesgit subtree pull

Estratégias de Atualização

# Pull com squash
git subtree pull --prefix=lib/demo \
    https://github.com/user/demo main --squash

# Pull preservando histórico
git subtree pull --prefix=lib/demo \
    https://github.com/user/demo main

Boas Práticas

Recomendações

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Prefixos claros    |
| • Squash quando útil |
| • Updates regulares  |
| • Documentação       |
| • Branches separados |
+------------------------+

Organização

# Criar alias para comandos comuns
git config alias.sba 'subtree add'
git config alias.sbp 'subtree pull'
git config alias.sbs 'subtree push'

Comparação com Submodules

Vantagens e Desvantagens

Subtrees vs SubmodulesSubtreesSubmodulesCódigo integradoHistórico unificadoMais simplesReferências exatasMenor repositórioMais complexo

Quando Usar

+------------------------+
|    SUBTREES           |
| • Código estável     |
| • Mudanças raras     |
| • Time único         |
|                      |
|    SUBMODULES        |
| • Updates frequentes |
| • Times separados    |
| • Versões exatas     |
+------------------------+

Troubleshooting

Problemas Comuns

ProblemasConflitosHistóricoPerformanceMerge manualResolução localSquash perdidoCommits duplicadosRepositório grandeClone lento

Soluções

# Resolver conflitos
git checkout --theirs lib/demo
git add lib/demo
git commit

# Limpar histórico
git subtree split --prefix=lib/demo --rejoin

Workflows Avançados

Contribuição Upstream

Split

Push

Pull Request

Desenvolvimento Local

Branch Temporária

Repositório Original

Merge Upstream

Automação

#!/bin/sh
# Script de atualização
for subtree in lib/*; do
    if [ -d "$subtree" ]; then
        prefix="lib/$(basename $subtree)"
        remote="https://github.com/user/$(basename $subtree)"
        git subtree pull --prefix=$prefix $remote main --squash
    fi
done

Dicas Avançadas

Performance

# Split otimizado
git subtree split --prefix=lib/demo \
    --onto=temp_branch -b new_branch

# Push seletivo
git subtree push --prefix=lib/demo \
    origin branch_name --rejoin

Manutenção

# Verificar subtrees
git log | grep -e "git-subtree-dir:"

# Limpar referências antigas
git gc --aggressive --prune=now

Próximos Passos

Tópicos Relacionados

Dica Pro: Use --squash ao adicionar subtrees para manter o histórico limpo, mas considere omiti-lo se precisar manter o histórico completo para referência.

Git Worktrees: Trabalhando com Múltiplos Diretórios

+------------------------+
|     Git Worktrees     |
|                       |
| Multiple Workspaces   |
| Parallel Development  |
| Resource Efficiency   |
|                       |
| Flexible Management   |
+------------------------+

Conceitos Básicos

O que são Worktrees?

Compartilha

Cria

Cria

Referencia

Referencia

Repositório Base

.git

Worktree 1

Worktree 2

Estrutura

projeto/
├── .git/
├── main/
│   └── [branch main]
├── feature/
│   └── [branch feature]
└── hotfix/
    └── [branch hotfix]

Comandos Essenciais

Operações Básicas

# Criar worktree
git worktree add ../feature feature-branch

# Listar worktrees
git worktree list

# Remover worktree
git worktree remove ../feature

# Mover worktree
git worktree move ../feature ../new-feature

Gerenciamento

# Criar nova branch com worktree
git worktree add -b nova-feature ../feature

# Limpar worktrees inacessíveis
git worktree prune

# Bloquear worktree
git worktree lock ../feature

Casos de Uso

Desenvolvimento Paralelo

HotfixFeatureMainHotfixFeatureMainCriar worktree featureCriar worktree hotfixDesenvolvimentoCorreção urgenteMerge hotfixMerge feature

Cenários Comuns

+------------------------+
|    CASOS DE USO       |
|                       |
| • Feature paralela   |
| • Hotfix urgente    |
| • Build separado    |
| • Review de PR      |
| • Testes isolados   |
+------------------------+

Boas Práticas

Recomendações

WorktreesOrganizaçãoManutençãoWorkflowEstrutura claraNomes descritivosPrune regularLock quando inativoBranch por worktreePropósito definido

Configuração

# Alias úteis
git config alias.wt 'worktree'
git config alias.wta 'worktree add'
git config alias.wtl 'worktree list'
git config alias.wtr 'worktree remove'

Troubleshooting

Problemas Comuns

ProblemasConflitosPerformanceReferênciasBranch ocupadoLock ativoDisco cheioMuitos worktreesBranch deletadoWorktree órfão

Soluções

# Resolver lock
git worktree unlock ../feature

# Limpar worktrees mortos
git worktree prune

# Forçar remoção
git worktree remove -f ../feature

Workflows Avançados

CI/CD

#!/bin/sh
# Script de build paralelo
for branch in feature/* ; do
    git worktree add "../build/${branch##*/}" $branch
    (cd "../build/${branch##*/}" && ./build.sh)
done

Automação

Criar

Build

Success

Fail

PR Recebido

Worktree Review

Testes

Merge

Cleanup

Dicas Avançadas

Performance

# Otimizar espaço
git worktree add --detach ../feature

# Checkout otimizado
git worktree add -f --checkout ../feature

Manutenção

+------------------------+
|    MANUTENÇÃO         |
|                       |
| • Backup .git        |
| • Prune regular     |
| • Monitor espaço    |
| • Check locks       |
| • Clean worktrees   |
+------------------------+

Integração com Ferramentas

IDE Support

IDEVSCodeJetBrainsEclipseMulti-rootWorkspaceProject groupsVCS rootsWorking setsGit support

Próximos Passos

Tópicos Relacionados

Dica Pro: Use worktrees para manter builds ou deploys separados do código fonte principal, facilitando a gestão de diferentes ambientes.

Git Bisect: Encontrando Bugs com Busca Binária

+------------------------+
|      Git Bisect       |
|                       |
| Bug Hunting           |
| Binary Search         |
| Automated Testing     |
|                       |
| Efficient Debugging   |
+------------------------+

Conceitos Básicos

Como Funciona

Início

Início

Testar

Bom

Ruim

Commit Bom

Busca Binária

Commit Ruim

Commit Médio

Metade Superior

Metade Inferior

Processo de Debug

CommitsBisectDeveloperCommitsBisectDeveloperStart bisectCheck commitTest resultMark good/bad

Comandos Essenciais

Operações Básicas

# Iniciar bisect
git bisect start
git bisect bad HEAD
git bisect good v1.0.0

# Marcar commits
git bisect good
git bisect bad

# Finalizar
git bisect reset

Automação

# Criar script de teste
echo '#!/bin/sh
make test' > test.sh
chmod +x test.sh

# Executar bisect automático
git bisect start
git bisect bad HEAD
git bisect good v1.0.0
git bisect run ./test.sh

Casos de Uso

Cenários Comuns

BisectPerformanceBugsTestesRegressõesGargalosFuncionaisVisuaisFalhasInstabilidades

Workflow Típico

+------------------------+
|    WORKFLOW           |
|                       |
| 1. Identificar bug   |
| 2. Definir limites   |
| 3. Iniciar bisect    |
| 4. Testar commits    |
| 5. Encontrar causa   |
+------------------------+

Boas Práticas

Recomendações

PráticasPreparaçãoExecuçãoAnáliseScripts prontosAmbiente limpoTestes rápidosLogs clarosDocumentarVerificar fix

Automação

# Script de teste completo
cat << 'EOF' > test.sh
#!/bin/sh
make build
if ! make test; then
    exit 1
fi
if ! ./performance_test.sh; then
    exit 1
fi
exit 0
EOF

Troubleshooting

Problemas Comuns

ProblemasAmbienteTestesEstadoBuild quebradoDeps faltandoFalsos positivosTimeoutWorking treeStash

Soluções

# Salvar trabalho atual
git stash

# Limpar ambiente
git clean -fdx

# Restaurar estado
git bisect reset
git stash pop

Workflows Avançados

CI Integration

#!/bin/sh
# Script para CI
git bisect start HEAD v1.0.0
git bisect run docker-compose run tests

Visualização

Bisect

Bad

Good

Found

Start

Commit 1

Commit 2

Commit 3

Bug Commit

Dicas Avançadas

Performance

# Skip builds desnecessários
git bisect skip HEAD
git bisect skip v2.1.0..v2.2.0

# Log detalhado
git bisect log > bisect_log.txt

Debug Avançado

+------------------------+
|    DEBUG AVANÇADO     |
|                       |
| • Logs detalhados    |
| • Skip commits       |
| • Visualização       |
| • Replay bisect     |
| • Terms custom      |
+------------------------+

Integração com Ferramentas

IDE Support

IDEVSCodeJetBrainsEclipseGit LensTimelineGit ToolboxVCS LogEGitHistory

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha scripts de teste prontos e otimizados para usar com bisect, economizando tempo em debugs futuros.

Git Filter-branch: Reescrevendo Histórico

+------------------------+
|    Filter-branch      |
|                       |
| History Rewriting     |
| Repository Cleaning   |
| Data Migration       |
|                       |
| Powerful but Complex  |
+------------------------+

Conceitos Básicos

O que é Filter-branch?

Filter-branchLimparReorganizarCorrigirArquivos grandesDados sensíveisSubdiretóriosHistóricoAutorEmail

Quando Usar

+------------------------+
|    CASOS DE USO       |
|                       |
| • Remover senhas     |
| • Limpar arquivos    |
| • Corrigir autoria   |
| • Mover diretórios   |
| • Dividir repos      |
+------------------------+

Comandos Essenciais

Operações Básicas

# Remover arquivo do histórico
git filter-branch --tree-filter 'rm -f senha.txt' HEAD

# Alterar email
git filter-branch --commit-filter '
    if [ "$GIT_AUTHOR_EMAIL" = "old@email.com" ];
    then
        GIT_AUTHOR_EMAIL="new@email.com";
        git commit-tree "$@";
    else
        git commit-tree "$@";
    fi' HEAD

Filtros Comuns

# Tree filter (manipula arquivos)
git filter-branch --tree-filter 'rm -rf node_modules' HEAD

# Index filter (mais rápido)
git filter-branch --index-filter 'git rm --cached --ignore-unmatch *.log' HEAD

# Env filter (modifica variáveis)
git filter-branch --env-filter '
    export GIT_AUTHOR_DATE="2023-01-01 12:00:00"
' HEAD

Casos de Uso Avançados

Limpeza de Repositório

CleanFilterRepoCleanFilterRepoIdentificar arquivosAplicar filtrosRemover objetosForçar push

Reorganização

# Mover diretório para raiz
git filter-branch --subdirectory-filter pasta HEAD

# Prefixar diretório
git filter-branch --tree-filter '
    mkdir -p novo/caminho
    mv * novo/caminho/ 2>/dev/null || true
' HEAD

Boas Práticas

Antes de Começar

Segurança

# Backup de refs
git branch backup-master master
git tag backup-tags

# Forçar reescrita
git filter-branch -f --index-filter 'git rm --cached --ignore-unmatch *.key' HEAD

Troubleshooting

Problemas Comuns

ProblemasPerformanceErrosConflitosRepos grandesFiltros lentosRefs lockedPath issuesPush rejectedRemote changes

Soluções

# Limpar backup
rm -rf .git/refs/original/

# Forçar garbage collection
git gc --aggressive --prune=now

# Forçar push
git push origin master --force

Alternativas Modernas

BFG Repo-Cleaner

# Remover arquivos grandes
bfg --strip-blobs-bigger-than 100M

# Substituir senhas
bfg --replace-text passwords.txt

Comparação

+------------------------+
|    COMPARAÇÃO         |
|                       |
| Filter-branch        |
| • Mais flexível      |
| • Mais complexo      |
| • Mais lento         |
|                       |
| BFG                  |
| • Mais rápido        |
| • Mais simples       |
| • Menos flexível     |
+------------------------+

Workflows Avançados

Automação

#!/bin/bash
# Script de limpeza completa
git filter-branch --force --index-filter \
    'git rm --cached --ignore-unmatch *.log' \
    --prune-empty --tag-name-filter cat -- --all

git for-each-ref --format="%(refname)" refs/original/ | \
    xargs -n 1 git update-ref -d

git reflog expire --expire=now --all
git gc --prune=now --aggressive

Integração CI/CD

Trigger

Execute

Validate

Success

Fail

Detect Issue

Filter Script

Filter-branch

Tests

Force Push

Rollback

Dicas Avançadas

Performance

# Usar index-filter em vez de tree-filter
git filter-branch --index-filter 'git rm --cached --ignore-unmatch arquivo.grande' HEAD

# Limitar escopo
git filter-branch --tree-filter 'comando' HEAD~10..HEAD

Manutenção

+------------------------+
|    MANUTENÇÃO         |
|                       |
| • Monitor tamanho    |
| • Backup regular     |
| • Teste em clone     |
| • Documentar mudanças|
| • Comunicar equipe   |
+------------------------+

Próximos Passos

Tópicos Relacionados

Dica Pro: Sempre teste filter-branch em um clone do repositório antes de aplicar no repositório principal. Mudanças são permanentes e podem ser difíceis de reverter.

Git Cherry-pick: Aplicando Commits Seletivamente

+------------------------+
|    Git Cherry-pick    |
|                       |
| Seleção de Commits    |
| Aplicação Precisa     |
| Integração Seletiva   |
|                       |
| Controle Granular     |
+------------------------+

Fundamentos do Cherry-pick

O que é Cherry-pick?

O cherry-pick é como um rebase para um único commit. Ele pega as alterações introduzidas em um commit específico e as aplica na branch atual, criando um novo commit com o mesmo conteúdo, mas com um hash diferente.

mainfeatureABCcherry-pick:C

Sintaxe Básica

# Formato básico
git cherry-pick <commit-hash>

# Exemplo prático
git cherry-pick abc123

# Cherry-pick múltiplos commits
git cherry-pick abc123 def456

# Cherry-pick de um range
git cherry-pick abc123^..def456

Técnicas Avançadas

Cherry-pick com Opções

# Cherry-pick sem commit automático
git cherry-pick --no-commit abc123

# Cherry-pick mantendo autoria original
git cherry-pick -x abc123

# Cherry-pick com mensagem personalizada
git cherry-pick -e abc123

# Cherry-pick apenas registrando (sem alterações)
git cherry-pick --signoff abc123

Resolvendo Conflitos

GitUsuárioGitUsuáriogit cherry-pick abc123Conflito!Resolve conflitogit add .git cherry-pick --continue
# Quando ocorrer conflito
git cherry-pick abc123
# ... conflito ocorre ...

# Resolver conflitos manualmente
# Depois:
git add .
git cherry-pick --continue

# Ou abortar o processo
git cherry-pick --abort

Casos de Uso

Backport de Correções

maindevelop1.0Fix Bugcherry-pick:Fix Bug3-ad301251.0.1
# Backport de uma correção
git checkout release/1.0
git cherry-pick abc123  # commit da correção
git tag v1.0.1
git push origin v1.0.1

Seleção de Features

+------------------------+
|    CASOS DE USO       |
|                       |
| • Backport de fixes   |
| • Seleção de features |
| • Recuperação parcial |
| • Migração seletiva   |
| • Testes isolados     |
+------------------------+

Estratégias e Padrões

Cherry-pick vs Merge vs Rebase

EstratégiasCherry-pickMergeRebaseSeletivoPrecisoNovo hashCompletoHistóricoCommit mergeSequencialLinearReescreve

Workflow com Cherry-pick

Commits

Review

Cherry-pick

Merge

Desenvolvimento

Feature Branch

Aprovação

Release Branch

Develop Branch

Boas Práticas

Quando Usar

✅ USE QUANDO:
• Precisa de commits específicos
• Backport de correções
• Migração seletiva
• Testes isolados

❌ EVITE QUANDO:
• Precisa de toda a branch
• Muitos commits sequenciais
• Histórico é importante
• Commits interdependentes

Dicas de Produtividade

# Alias útil para cherry-pick
git config --global alias.cp 'cherry-pick'

# Cherry-pick com mensagem personalizada
git cp -e abc123

# Cherry-pick múltiplos commits
git cp --no-commit abc123 def456 ghi789
git commit -m "Aplica features X, Y e Z"

Troubleshooting

Problemas Comuns

ProblemasConflitosDependênciasDuplicaçãoManuaisEstratégiasOrdemFaltantesMesmo códigoDiferentes hashes

Soluções

# Conflito complexo
git cherry-pick --abort
git checkout -b temp-branch
git merge feature-branch
# Resolver manualmente
git checkout main
git cherry-pick temp-branch

# Verificar diferenças antes
git show abc123

Automação

Scripts Úteis

#!/bin/bash
# Cherry-pick todos os commits de uma branch que contêm uma palavra-chave
cherry_pick_by_keyword() {
    local branch="$1"
    local keyword="$2"
    
    git log --grep="$keyword" --format="%H" "$branch" | 
    tac | 
    xargs -I{} git cherry-pick {}
}

# Uso: cherry_pick_by_keyword feature/login "auth"

CI/CD Integration

name: Backport Fixes
on:
  pull_request:
    types: [closed]
    branches: [main]
jobs:
  backport:
    if: github.event.pull_request.merged == true && contains(github.event.pull_request.labels.*.name, 'backport')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - name: Backport
        run: |
          git checkout release/1.0
          git cherry-pick ${{ github.event.pull_request.merge_commit_sha }}
          git push origin release/1.0

Próximos Passos

Tópicos Relacionados

Dica Pro: O cherry-pick é uma ferramenta poderosa, mas use com moderação. Commits frequentemente cherry-picked podem indicar problemas no seu workflow de branches.

Git Testing: Garantindo Qualidade no Versionamento

+------------------------+
|     Git Testing       |
|                       |
| Testes Automatizados  |
| Validação             |
| Qualidade             |
|                       |
| Confiabilidade        |
+------------------------+

Fundamentos

Tipos de Testes

TestesUnitáriosIntegraçãoE2ECommitsHooksWorkflowsPipelinesCenáriosFluxos

Framework de Testes

# Estrutura básica
tests/
├── unit/
│   ├── commit_test.sh
│   └── hook_test.sh
├── integration/
│   ├── workflow_test.sh
│   └── pipeline_test.sh
└── e2e/
    ├── scenarios/
    └── flows/

Testes Unitários

Testando Commits

#!/bin/bash
test_commit_message() {
    message="$1"
    if ! echo "$message" | grep -qE "^(feat|fix|docs|style|refactor|test|chore):"; then
        return 1
    fi
    return 0
}

Testando Hooks

#!/bin/bash
test_pre_commit_hook() {
    # Setup
    cp .git/hooks/pre-commit{,.bak}
    
    # Test
    ./pre-commit.sh
    result=$?
    
    # Cleanup
    mv .git/hooks/pre-commit{.bak,}
    return $result
}

Testes de Integração

Workflow Tests

Prepare

Validate

Cleanup

Setup

Execute

Assert

Report

Pipeline Tests

name: Git Integration Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run Tests
        run: |
          ./run_integration_tests.sh

Testes E2E

Cenários Comuns

#!/bin/bash
test_branch_workflow() {
    # Setup
    git checkout -b feature/test
    
    # Test
    echo "test" > file.txt
    git add file.txt
    git commit -m "test: add file"
    git push origin feature/test
    
    # Assert
    git log --oneline | grep "test: add file"
    
    # Cleanup
    git checkout main
    git branch -D feature/test
}

Automação E2E

def test_git_workflow():
    """
    Teste completo de workflow Git
    """
    # Setup
    repo = setup_test_repo()
    
    # Execute
    create_branch(repo)
    make_changes(repo)
    create_pr(repo)
    
    # Assert
    assert verify_pr(repo)
    
    # Cleanup
    cleanup_repo(repo)

Ferramentas

Test Runners

Relatórios

+------------------------+
|    TEST REPORT        |
|                       |
| ✓ Commit Tests       |
| ✓ Hook Tests         |
| ✓ Workflow Tests     |
| ✗ Pipeline Tests     |
| ✓ E2E Tests          |
+------------------------+

Boas Práticas

Organização

  1. Estrutura clara de testes

  2. Nomenclatura consistente

  3. Isolamento de testes

  4. Limpeza após testes

  5. Documentação adequada

Automação

#!/bin/bash
# Script de teste completo
run_all_tests() {
    echo "Running unit tests..."
    ./run_unit_tests.sh
    
    echo "Running integration tests..."
    ./run_integration_tests.sh
    
    echo "Running E2E tests..."
    ./run_e2e_tests.sh
}

CI/CD Integration

GitHub Actions

name: Git Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Unit Tests
        run: ./run_unit_tests.sh
      - name: Integration Tests
        run: ./run_integration_tests.sh
      - name: E2E Tests
        run: ./run_e2e_tests.sh

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha seus testes atualizados e execute-os frequentemente para garantir a qualidade do seu workflow Git.

Git Automation: Otimizando Workflows

+------------------------+
|    Git Automation     |
|                       |
| Scripts               |
| Hooks                 |
| CI/CD                 |
|                       |
| Produtividade         |
+------------------------+

Fundamentos

Tipos de Automação

AutomaçãoScriptsHooksCI/CDShellPythonPre-commitPost-commitActionsPipelines

Scripts de Automação

Workflow Scripts

#!/bin/bash
# Script de automação de workflow
automate_workflow() {
    # Update branches
    git fetch --all
    git pull origin main
    
    # Clean old branches
    git branch --merged | grep -v "\*" | xargs -n 1 git branch -d
    
    # Run tests
    ./run_tests.sh
    
    # Update dependencies
    npm update
}

Batch Operations

def batch_operations():
    """
    Operações em lote no Git
    """
    repos = get_all_repos()
    for repo in repos:
        with cd(repo):
            update_dependencies()
            run_tests()
            create_backup()

Git Hooks

Pre-commit Hook

#!/bin/bash
# .git/hooks/pre-commit
set -e

echo "🔍 Verificando código..."
npm run lint

echo "🧪 Executando testes..."
npm test

echo "📦 Verificando build..."
npm run build

Post-commit Hook

#!/bin/bash
# .git/hooks/post-commit
set -e

# Notify team
./notify_team.sh

# Update documentation
./update_docs.sh

# Run deployment if on main
if [[ $(git branch --show-current) == "main" ]]; then
    ./deploy.sh
fi

CI/CD Automation

GitHub Actions

name: Git Automation
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]
jobs:
  automate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run Automation
        run: |
          ./automate_workflow.sh

Jenkins Pipeline

pipeline {
    agent any
    stages {
        stage('Automate') {
            steps {
                sh './automate_workflow.sh'
            }
        }
    }
}

Ferramentas

CLI Tools

ToolsHuskyCommitizenSemantic ReleaseHooksScriptsCommitsMessagesVersioningChangelog

Integrations

+------------------------+
|    INTEGRATIONS       |
|                       |
| • GitHub             |
| • GitLab             |
| • Bitbucket          |
| • Jenkins            |
| • Travis CI          |
+------------------------+

Boas Práticas

Organização

.
├── scripts/
│   ├── automation/
│   ├── hooks/
│   └── ci/
├── .github/
│   └── workflows/
└── tools/
    └── automation/

Logging

def log_automation(action, status, message):
    """
    Log automation actions
    """
    timestamp = datetime.now()
    log_entry = f"[{timestamp}] {action}: {status} - {message}"
    logging.info(log_entry)

Monitoramento

Métricas

Alertas

alerts:
  - name: automation_failure
    condition: status != 'success'
    channels:
      - slack
      - email
    threshold: 1

Troubleshooting

Debug

#!/bin/bash
# Debug automation
set -x
export DEBUG=true

run_automation() {
    echo "Starting automation..."
    ./automate_workflow.sh 2>&1 | tee automation.log
}

Recovery

#!/bin/bash
# Recovery script
recover_automation() {
    # Backup current state
    git stash
    
    # Reset to last known good state
    git reset --hard last_good_commit
    
    # Retry automation
    ./automate_workflow.sh
}

Próximos Passos

Tópicos Relacionados

Dica Pro: Automatize tarefas repetitivas, mas mantenha a flexibilidade para casos especiais.

Ferramentas Git: Expandindo Suas Capacidades

+------------------------+
|     Git Tools         |
|                       |
| GUI Clients          |
| Extensions           |
| LFS                  |
| Credentials          |
|                       |
| Power User Tools     |
+------------------------+

Visão Geral

Categorias

Git ToolsGUICLIStorageSecurityClientes visuaisIDEsExtensionsScriptsLFSHooksCredentialsKeys

Ferramentas Essenciais

GUI Clients

GUI Clients

GitKraken

SourceTree

GitHub Desktop

Git Tower

Pro Features

Free Features

Extensões Populares

IDE Integration

IDEsVSCodeJetBrainsEclipseGitLensGit GraphGit ToolboxGitFlowEGitGit Flow

Produtividade

+------------------------+
|    PRODUTIVIDADE      |
|                       |
| • Auto-complete      |
| • Aliases            |
| • Scripts            |
| • Hooks              |
| • Templates          |
+------------------------+

Git LFS

Configuração Básica

# Instalar Git LFS
git lfs install

# Rastrear arquivos grandes
git lfs track "*.psd"
git lfs track "*.zip"

# Verificar tracking
git lfs ls-files

Workflow LFS

RemoteLFSDeveloperRemoteLFSDeveloperTrack large fileStore pointerDownload when neededWork with file

Gerenciamento de Credenciais

Helpers Disponíveis

CredentialsWindowsmacOSLinuxCredential ManagerWinCredKeychainosxkeychainlibsecretcache

Configuração

# Windows
git config --global credential.helper manager

# macOS
git config --global credential.helper osxkeychain

# Linux
git config --global credential.helper cache

Integrações

CI/CD Tools

Git

Jenkins

GitHub Actions

GitLab CI

CircleCI

Project Management

+------------------------+
|    INTEGRAÇÕES        |
|                       |
| • Jira               |
| • Trello             |
| • Monday             |
| • Asana              |
| • ClickUp            |
+------------------------+

Dicas Avançadas

Customização

# Aliases personalizados
git config --global alias.standup "log --since yesterday --author $(git config user.email)"
git config --global alias.undo "reset HEAD~1 --mixed"

# Scripts úteis
echo '#!/bin/sh
git checkout master
git pull origin master
git checkout -' > .git/hooks/post-commit

Automação

Pre-commit

Pre-push

Post-merge

Post-checkout

Hooks

Lint

Tests

Update

Clean

Próximos Passos

Tópicos Relacionados

Dica Pro: Experimente diferentes ferramentas para encontrar o conjunto que melhor se adapta ao seu workflow. Não existe uma solução única para todos.

Interfaces Gráficas Git

+------------------------+
|      Git GUIs         |
|                       |
| Visual Clients       |
| IDE Integration      |
| Repository View      |
|                       |
| User Experience     |
+------------------------+

Clientes Populares

Principais Opções

Git GUIsGitKrakenSourceTreeGitHub DesktopGit TowerInterface modernaIntegração GitHubMerge toolsGratuitoAtlassian SuiteVisual diffSimplicidadeGitHub focusedPull requestsProfissionalMulti-platformAdvanced features

Comparativo

Recursos

+------------------------+
|      RECURSOS         |
|                       |
| • Visual Diff        |
| • Merge Tools        |
| • Branch View        |
| • History Graph      |
| • Stash UI          |
| • Rebase Interface  |
+------------------------+

Performance

Performance

GitKraken

SourceTree

GitHub Desktop

Git Tower

RAM Usage: High

RAM Usage: Medium

RAM Usage: Low

RAM Usage: Medium

IDE Integration

Plugins Populares

Funcionalidades Essenciais

Visual Diff & Merge

+------------------------+
|    DIFF & MERGE       |
|                       |
| • Side-by-side       |
| • Syntax highlight   |
| • Conflict resolver  |
| • Chunk selection    |
| • Interactive rebase |
+------------------------+

History Visualization

History

Network Graph

Timeline

Branch View

Commit Details

Author Info

Merge Points

Escolhendo uma GUI

Fatores de Decisão

EscolhaNecessidadesPlataformaPreçoIntegraçãoBásicoAvançadoWindowsmacOSLinuxGratuitoPagoGitHubGitLabBitbucket

Recomendações

+------------------------+
|    POR PERFIL        |
|                       |
| Iniciante            |
| • GitHub Desktop     |
|                       |
| Intermediário        |
| • SourceTree        |
|                       |
| Avançado            |
| • GitKraken         |
| • Git Tower         |
+------------------------+

Dicas de Uso

Produtividade

# Atalhos comuns
Ctrl/Cmd + S    # Stage changes
Ctrl/Cmd + K    # Commit
Ctrl/Cmd + P    # Push
Ctrl/Cmd + L    # Pull

Workflow Integration

RemoteGUIDeveloperRemoteGUIDeveloperView changesStage/UnstageCommitPush/Pull

Próximos Passos

Tópicos Relacionados

Dica Pro: Combine GUI com linha de comando para maior produtividade - use cada ferramenta onde ela é mais eficiente.

Extensões Git

+------------------------+
|    Git Extensions     |
|                       |
| IDE Plugins          |
| CLI Extensions       |
| Custom Scripts       |
|                       |
| Productivity Tools   |
+------------------------+

Extensões Populares

IDE Plugins

IDE PluginsVSCodeJetBrainsEclipseGitLensGit HistoryGit GraphGit4IdeaGitToolBoxEGitGit Flow

Instalação e Configuração

Package Managers

# VSCode
code --install-extension eamodio.gitlens

# npm global
npm install -g git-open

# Homebrew
brew install git-flow

Configuração Manual

# Adicionar ao PATH
export PATH=$PATH:/caminho/para/extensao

# Configurar alias
git config --global alias.custom-cmd '!path/to/script.sh'

Extensões Recomendadas

Produtividade

+------------------------+
|    RECOMENDADAS       |
|                       |
| • GitLens            |
| • Git Flow           |
| • Git Open           |
| • Git Recent         |
| • Git Interactive    |
+------------------------+

Integração

Git Core

Extensions

IDE Integration

CLI Tools

Custom Scripts

Próximos Passos

Tópicos Relacionados

Dica Pro: Comece com extensões básicas e adicione mais conforme sua necessidade específica.

Git LFS

+------------------------+
|      Git LFS          |
|                       |
| Large File Handling   |
| Binary Management    |
| Storage Optimization |
|                       |
| Performance Boost    |
+------------------------+

Conceitos Básicos

O que é Git LFS?

Git LFSArquivosBenefíciosTrackingGrandesBináriosPerformanceEconomiaPatternsPointers

Configuração

Instalação

# Instalar Git LFS
git lfs install

# Verificar instalação
git lfs version

Tracking

# Iniciar tracking
git lfs track "*.psd"
git lfs track "*.zip"
git lfs track "*.iso"

# Listar patterns
git lfs track

# Verificar arquivos
git lfs ls-files

Uso Diário

Comandos Básicos

# Status
git lfs status

# Pull com LFS
git lfs pull

# Fetch específico
git lfs fetch origin master

# Prune
git lfs prune

Workflow

RemoteLFSDeveloperRemoteLFSDeveloperAdd large fileCreate pointerPush to storagePush pointer

Boas Práticas

Otimização

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Track seletivo     |
| • Prune regular      |
| • Backup separado    |
| • Monitorar uso      |
+------------------------+

Próximos Passos

Tópicos Relacionados

Dica Pro: Use Git LFS desde o início do projeto para arquivos grandes - migrar posteriormente pode ser desafiador.

Git Credential Helpers

+------------------------+
| Credential Helpers    |
|                       |
| Secure Storage       |
| Authentication       |
| Platform Integration |
|                       |
| Security Best        |
+------------------------+

Helpers Disponíveis

Por Plataforma

HelpersWindowsmacOSLinuxManagerWinCredKeychainosxkeychainlibsecretcache

Configuração

Setup Básico

# Windows
git config --global credential.helper manager

# macOS
git config --global credential.helper osxkeychain

# Linux
git config --global credential.helper cache

Cache Options

# Definir timeout
git config --global credential.helper 'cache --timeout=3600'

# Limpar cache
git credential-cache exit

Segurança

Boas Práticas

+------------------------+
|    SEGURANÇA          |
|                       |
| • Timeout curto      |
| • HTTPS preferido    |
| • 2FA ativado       |
| • Tokens únicos     |
| • Revisão regular   |
+------------------------+

Troubleshooting

Problema

Verificar Config

Limpar Cache

Reconfigurar

Testar

Próximos Passos

Tópicos Relacionados

Dica Pro: Use diferentes credenciais para diferentes repositórios quando necessário por segurança.

Hospedagem Git: Plataformas e Soluções

+------------------------+
|    Git Hosting        |
|                       |
| Cloud Services       |
| Self-Hosted         |
| Features            |
|                       |
| Platform Choice     |
+------------------------+

Plataformas Principais

Comparativo

HostingGitHubGitLabBitbucketActionsPackagesPagesCodespacesCI/CDRegistryWikiIssuesPipelinesJiraConfluenceBamboo

Critérios de Escolha

Fatores Decisivos

+------------------------+
|    CONSIDERAR         |
|                       |
| • Custo              |
| • Integração         |
| • Escalabilidade     |
| • Segurança          |
| • Compliance         |
| • Suporte            |
+------------------------+

Comparativo de Preços

Preços

GitHub

GitLab

Bitbucket

Free/Team/Enterprise

Free/Premium/Ultimate

Free/Standard/Premium

Self-Hosted vs Cloud

Análise

Próximos Passos

Tópicos Relacionados

Dica Pro: Avalie cuidadosamente as necessidades específicas do seu projeto e equipe antes de escolher uma plataforma.

GitHub: Recursos e Funcionalidades Específicas

GitHub Actions

Workflows Básicos

# .github/workflows/ci.yml
name: CI
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: npm ci
      - run: npm test

Matriz de Testes

strategy:
  matrix:
    node-version: [14, 16, 18]
    os: [ubuntu-latest, windows-latest]

Segurança

Dependabot

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"

Code Scanning

name: "CodeQL"
on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]

GitHub Packages

Configuração NPM

# .npmrc
@owner:registry=https://npm.pkg.github.com
//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}

Docker Publishing

# Login no GHCR
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin

# Push da imagem
docker push ghcr.io/owner/image:tag

GitHub Pages

Configuração Jekyll

# _config.yml
remote_theme: owner/theme
plugins:
  - jekyll-feed
  - jekyll-seo-tag

Deploy Automático

name: Deploy Pages
on:
  push:
    branches: [ main ]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: npm run build
      - uses: peaceiris/actions-gh-pages@v3

GitHub Codespaces

Configuração Dev Container

{
  "name": "Node.js",
  "image": "mcr.microsoft.com/devcontainers/javascript-node:18",
  "customizations": {
    "vscode": {
      "extensions": [
        "dbaeumer.vscode-eslint",
        "esbenp.prettier-vscode"
      ]
    }
  }
}

Prebuild Configuration

name: Prebuild
on:
  push:
    branches: [ main ]
jobs:
  prebuild:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: github/codespaces/prebuild@v1

Integrações e Apps

GitHub CLI

# Comandos úteis
gh repo create
gh pr create
gh issue list
gh workflow run

GitHub Desktop

Clone

Branch

Commit

Push

Pull Request

Boas Práticas

Pull Requests

## Template PR
### Descrição
- O que mudou?
- Por que mudou?

### Checklist
- [ ] Testes
- [ ] Documentação
- [ ] Code Review

Branch Protection

ProteçõesReviewsStatusRegrasObrigatórioAprovaçõesCI ChecksDeployLinear HistoryForce Push

Monitoramento

Insights

+------------------------+
|    MÉTRICAS           |
|                       |
| • Contributors       |
| • Traffic           |
| • Dependencies      |
| • Security          |
+------------------------+

Actions Usage

Builds

Minutes

Custos

Otimização

Dicas Avançadas

GitHub API

# Exemplos de uso da API
curl -H "Authorization: token ${GITHUB_TOKEN}" \
     https://api.github.com/repos/owner/repo/issues

# GraphQL
curl -H "Authorization: bearer ${GITHUB_TOKEN}" \
     -X POST -d '{"query": "..."}' \
     https://api.github.com/graphql

Automações Custom

// Webhook handler
app.post('/webhook', (req, res) => {
  const { action, issue } = req.body;
  if (action === 'opened') {
    // Handle new issue
  }
});

Dica Pro: Use GitHub Actions para automatizar tarefas repetitivas e manter consistência no projeto.

GitLab: Recursos e Funcionalidades Específicas

CI/CD Avançado

Pipeline Completa

# .gitlab-ci.yml
stages:
  - build
  - test
  - security
  - deploy

variables:
  DOCKER_IMAGE: $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

build:
  stage: build
  script:
    - docker build -t $DOCKER_IMAGE .
    - docker push $DOCKER_IMAGE

test:
  stage: test
  services:
    - postgres:13
  variables:
    POSTGRES_DB: test_db
  script:
    - npm run test
    - npm run e2e

security_scan:
  stage: security
  script:
    - gitlab-sast
    - gitlab-dependency-scan

deploy_staging:
  stage: deploy
  environment: staging
  script:
    - kubectl apply -f k8s/
  only:
    - develop

Runner Configuration

[[runners]]
  name = "docker-runner"
  url = "https://gitlab.com"
  token = "TOKEN"
  executor = "docker"
  [runners.docker]
    tls_verify = false
    image = "docker:latest"
    privileged = true

Container Registry

Docker Integration

# Login
docker login registry.gitlab.com

# Build e Tag
docker build -t registry.gitlab.com/group/project .
docker push registry.gitlab.com/group/project

Kubernetes Integration

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
spec:
  template:
    spec:
      containers:
      - name: app
        image: registry.gitlab.com/group/project:latest
      imagePullSecrets:
      - name: gitlab-registry

Security Features

SAST Configuration

sast:
  stage: security
  script:
    - gitlab-sast
  artifacts:
    reports:
      sast: gl-sast-report.json

Dependency Scanning

dependency_scanning:
  image: registry.gitlab.com/gitlab-org/security-products/dependency-scanning
  script:
    - /analyzer run

Wiki e Documentação

Markdown Templates

# Projeto XYZ

## Visão Geral
- Descrição
- Objetivos
- Arquitetura

## Setup
```bash
git clone ${repo}
npm install
npm start

Contribuição

  1. Fork

  2. Branch

  3. PR

### Auto Doc Generation
```yaml
pages:
  stage: deploy
  script:
    - mkdocs build
    - mv site public
  artifacts:
    paths:
      - public

Monitoramento

Métricas

Prometheus

Metrics

Grafana

Dashboards

Alerting

alerting:
  rules:
    - alert: HighErrorRate
      expr: error_rate > 0.5
      for: 5m
      labels:
        severity: critical

Integração com Kubernetes

Auto DevOps

include:
  - template: Auto-DevOps.gitlab-ci.yml

variables:
  POSTGRES_ENABLED: "true"
  STAGING_ENABLED: "true"
  PRODUCTION_ENABLED: "true"

Cluster Integration

GitLab

Cluster

Ingress

Services

Gerenciamento de Acesso

RBAC

roles:
  - name: developer
    access_level: 30
    permissions:
      - push_code
      - create_merge_request

Group Management

Analytics e Reporting

Value Stream

+------------------------+
|    MÉTRICAS           |
|                       |
| • Lead Time          |
| • Cycle Time         |
| • Deployment Freq    |
| • Change Failure     |
+------------------------+

Custom Reports

# Generate custom report
GitLab::Report.new do |r|
  r.add_metric(:deployments)
  r.add_metric(:issues)
  r.export_csv
end

Próximos Passos

Recursos Adicionais

Dica Pro: Use Auto DevOps para começar rapidamente com CI/CD e depois customize conforme necessário.

Bitbucket: Recursos e Funcionalidades Específicas

Pipelines

Configuração Básica

# bitbucket-pipelines.yml
image: node:16

pipelines:
  default:
    - step:
        name: Build and Test
        caches:
          - node
        script:
          - npm install
          - npm test
        artifacts:
          - dist/**

Pipeline Avançada

pipelines:
  branches:
    main:
      - step:
          name: Build
          script:
            - npm install
            - npm run build
      - step:
          name: Test
          script:
            - npm test
      - step:
          name: Deploy to Production
          deployment: production
          script:
            - pipe: atlassian/aws-elasticbeanstalk-deploy

Integração Jira

Smart Commits

# Formato
git commit -m "PROJ-123 #time 2h #comment Implementando feature"

Workflow Integration

Commit

Branch

Pull Request

Code Review

Merge

Jira Update

Confluence Integration

Documentação Automática

# Template de Página
{code:title=Exemplo|language=java}
public class Example {
    // Código aqui
}
{code}

{status:colour=Green|title=Build Status}
Passed
{status}

Code Snippets

# Macro de código
{bitbucket:repo=project/repo|file=src/main.js|lines=10-20}

Segurança

Access Management

SegurançaPermissõesIP Whitelist2FARepo LevelProject LevelAdmin LevelOfficeVPNRequiredBackup Codes

Branch Restrictions

+------------------------+
|    PROTEÇÕES          |
|                       |
| • Merge Check        |
| • Build Status       |
| • Approvals          |
| • Branch Pattern     |
+------------------------+

Code Insights

SonarQube Integration

definitions:
  services:
    sonar:
      image: sonarqube:latest

pipelines:
  default:
    - step:
        services:
          - sonar
        script:
          - sonar-scanner

Code Coverage

- step:
    name: Code Coverage
    script:
      - npm run coverage
    after-script:
      - pipe: atlassian/bitbucket-upload-coverage
        variables:
          COVERAGE_REPORTS: 'coverage/lcov.info'

Deployment

Environments

deployments:
  staging:
    - step:
        script:
          - aws deploy create-deployment
  production:
    - step:
        trigger: manual
        script:
          - aws deploy create-deployment

Deployment Variables

# Configuração de variáveis
bitbucket pipelines variables add \
  --key AWS_ACCESS_KEY_ID \
  --value $ACCESS_KEY \
  --secured

Webhooks e API

Webhook Configuration

{
  "url": "https://api.example.com/webhook",
  "events": [
    "repo:push",
    "pullrequest:created",
    "pullrequest:merged"
  ]
}

API Usage

from atlassian import Bitbucket

bitbucket = Bitbucket(
    url='https://bitbucket.org',
    username='admin',
    password='admin'
)

# Get repository info
repo = bitbucket.get_repo('project', 'repository')

Backup e Manutenção

Backup Strategy

Maintenance Scripts

#!/bin/bash
# Backup script
for repo in $(bitbucket repos list); do
  git clone --mirror $repo
  tar czf "${repo}.tar.gz" "${repo}.git"
done

Monitoramento

Status Page

StatusServicesMetricsAlertsGitPipelinesUptimeResponseEmailSlack

Performance Metrics

+------------------------+
|    MÉTRICAS           |
|                       |
| • Response Time      |
| • Build Time         |
| • Success Rate       |
| • Error Rate         |
+------------------------+

Próximos Passos

Recursos Adicionais

Dica Pro: Use Smart Commits para integração eficiente com Jira e automatização de workflows.

Self-Hosted Git

+------------------------+
|    Self-Hosted        |
|                       |
| Installation         |
| Configuration       |
| Maintenance         |
|                       |
| Security            |
+------------------------+

Soluções Populares

Opções

Self-HostedGitLab CEGiteaGogsFreeCompleteScalableLightweightFastSimpleBasicEfficientMinimal

Instalação

Setup Básico

# GitLab CE
curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash
sudo apt install gitlab-ce

# Gitea
docker run -d --name=gitea -p 3000:3000 gitea/gitea:latest

Manutenção

Backup

+------------------------+
|    BACKUP TYPES       |
|                       |
| • Repositórios       |
| • Configurações      |
| • Banco de dados     |
| • Uploads            |
+------------------------+

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um ambiente de teste para validar atualizações antes de aplicar em produção.

Segurança no Git

Visão Geral

Segurança GitAutenticaçãoAssinaturaSecretsBoas PráticasSSHHTTPS2FA/MFAGPGCommitsTagsPrevençãoDetecçãoMitigaçãoPermissõesAuditoriasBackups

Componentes Principais

Pilares de Segurança

Segurança Git

Autenticação

Autorização

Integridade

Auditoria

Credenciais

Permissões

Verificação

Logs

Ameaças Comuns

Vetores de Ataque

+------------------------+
|    AMEAÇAS COMUNS     |
|                       |
| • Credenciais vazadas |
| • Commits maliciosos  |
| • Histórico alterado  |
| • Acesso não autor.   |
| • Secrets expostos    |
+------------------------+

Estratégias de Proteção

Camadas de Segurança

Repositório

Hooks

Análise

Validação

Logs

Ferramentas Recomendadas

  1. Git-secrets

  2. GitGuardian

  3. TruffleHog

  4. pre-commit hooks

  5. GPG Suite

Monitoramento

Logs de Segurança

AlertasLogsGitUsuárioAlertasLogsGitUsuárioAçãoRegistroAnáliseNotificação

Próximos Passos

Tópicos Relacionados

  • Assinatura de commits e tags

  • Gerenciamento de secrets

  • Autenticação segura

  • Melhores práticas

Nota: A segurança é um processo contínuo que requer atenção constante e atualizações regulares das práticas e ferramentas utilizadas.

Assinatura de Commits e Tags

Configuração GPG

Setup Inicial

# Gerar chave GPG
gpg --full-generate-key

# Listar chaves
gpg --list-secret-keys --keyid-format LONG

# Configurar Git
git config --global user.signingkey [KEY_ID]
git config --global commit.gpgsign true

Assinando Commits

Processo de Assinatura

GPGGitDeveloperGPGGitDevelopergit commitSolicita assinaturaPede senhaFornece senhaAssina commitCommit concluído

Comandos Básicos

# Commit assinado
git commit -S -m "commit message"

# Verificar assinaturas
git verify-commit HEAD
git verify-tag v1.0.0

# Listar commits assinados
git log --show-signature

Verificação

Status de Assinatura

Verificar

Sim

Não

Chave confiável

Chave desconhecida

Commit

Assinado?

Válido

Não assinado

Verificado

Não verificado

Boas Práticas

Recomendações

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Backup das chaves   |
| • Rotação periódica   |
| • Senha forte         |
| • Chave dedicada     |
| • Expiração definida |
+------------------------+

Troubleshooting

Problemas Comuns

Soluções

# Testar GPG
echo "test" | gpg --clearsign

# Reconfigurar Git GPG
git config --global --unset user.signingkey
git config --global user.signingkey [NEW_KEY_ID]

# Exportar chave pública
gpg --armor --export [KEY_ID]

Integração CI/CD

Verificação Automatizada

name: Verify Signatures
on: [push, pull_request]

jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Verify commits
        run: |
          git verify-commit HEAD

Próximos Passos

Tópicos Relacionados

  • Gerenciamento de chaves GPG

  • Políticas de assinatura

  • Integração com plataformas Git

  • Automação de verificação

Dica Pro: Mantenha um backup seguro de suas chaves GPG e considere usar um hardware security module (HSM) para maior segurança.

Gerenciamento de Secrets no Git

Prevenção

Ferramentas de Detecção

Scan

Detectado

Limpo

Correção

Código

git-secrets

Bloqueia Commit

Permite Commit

Configuração git-secrets

# Instalação
git secrets --install
git secrets --register-aws

# Regras personalizadas
git secrets --add 'private_key'
git secrets --add 'api_key'
git secrets --add 'password'

Detecção

Padrões Comuns

+------------------------+
|    SECRETS COMUNS     |
|                       |
| • API Keys            |
| • Tokens              |
| • Senhas             |
| • Certificados       |
| • Chaves privadas    |
+------------------------+

Implementação de Hooks

#!/bin/sh
# pre-commit hook
if git secrets --scan; then
    exit 0
else
    echo "Secrets detectados!"
    exit 1
fi

Mitigação

Processo de Limpeza

RepositoryGitDeveloperRepositoryGitDeveloperDetecta secretNotificagit filter-branchForce pushRevoga credentials

Comandos de Limpeza

# Remover arquivo com secret
git filter-branch --force --index-filter \
  "git rm --cached --ignore-unmatch config.json" \
  --prune-empty --tag-name-filter cat -- --all

# Forçar push
git push origin --force --all

Prevenção Automatizada

CI/CD Integration

name: Secret Scanner
on: [push, pull_request]

jobs:
  scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: TruffleHog
        uses: trufflesecurity/trufflehog-actions-scan@main

Boas Práticas

Gestão de Configuração

Armazenamento Seguro

  1. Variáveis de ambiente

  2. Gestores de segredo

  3. Cofres de senha

  4. Serviços de configuração

Monitoramento

Auditoria Contínua

AuditoriaScansAlertasRelatóriosRepositórioCommitsPRsEmailSlackDashboardMétricasTendênciasIncidentes

Recuperação

Plano de Ação

Imediata

Rápida

Completa

Preventiva

Detecção

Contenção

Remoção

Rotação

Documentação

Checklist de Incidente

  1. Identificar exposição

  2. Revogar credenciais

  3. Limpar histórico

  4. Atualizar secrets

  5. Documentar incidente

Próximos Passos

Tópicos Relacionados

  • Criptografia

  • Gestão de credenciais

  • Políticas de segurança

  • Automação de segurança

Dica Pro: Implemente múltiplas camadas de proteção e mantenha uma lista atualizada de padrões de secrets para detecção.

Autenticação no Git

Métodos de Autenticação

Visão Geral

AutenticaçãoSSHHTTPSOutrosChavesConfigAgentTokensCredentials2FAKerberosLDAPOAuth

SSH

Configuração

# Gerar chave SSH
ssh-keygen -t ed25519 -C "email@example.com"

# Iniciar ssh-agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Testar conexão
ssh -T git@github.com

Estrutura

~/.ssh/
├── config
├── id_ed25519
├── id_ed25519.pub
└── known_hosts

HTTPS

Token de Acesso

RepositórioGit HostUsuárioRepositórioGit HostUsuárioSolicita tokenGera tokenClone/Push com tokenValida tokenAutoriza acesso

Credential Helper

# Windows
git config --global credential.helper manager

# macOS
git config --global credential.helper osxkeychain

# Linux
git config --global credential.helper cache

Multi-Factor Authentication (MFA)

Fluxo 2FA

Senha

Token

Sucesso

Falha

Login

1º Fator

2º Fator

Acesso

Bloqueio

Configuração

  1. Aplicativo autenticador

  2. SMS/Email backup

  3. Chaves de recuperação

  4. Dispositivos confiáveis

Gestão de Credenciais

Boas Práticas

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Rotação regular     |
| • Escopos mínimos    |
| • Auditoria de uso   |
| • Backup seguro      |
| • Revogação rápida   |
+------------------------+

Automação

name: Token Rotation
on:
  schedule:
    - cron: '0 0 1 * *'
jobs:
  rotate:
    runs-on: ubuntu-latest
    steps:
      - name: Rotate credentials
        run: ./rotate-credentials.sh

Troubleshooting

Problemas Comuns

ProblemasSSHHTTPS2FAPermissõesChave inválidaAgentToken expiradoCacheProxySincronizaçãoBackup codesDevice lost

Soluções

# Verificar SSH
ssh -vT git@github.com

# Limpar cache
git credential-cache exit

# Testar conexão
git ls-remote

Integração Enterprise

LDAP/AD

Auth

Validate

Groups

Git Client

LDAP

AD

Permissions

SSO

  1. SAML 2.0

  2. OAuth 2.0

  3. OpenID Connect

  4. Custom providers

Monitoramento

Auditoria

Log

Análise

Ação

Login

Eventos

Alertas

Resposta

Métricas

  1. Tentativas de login

  2. Falhas de autenticação

  3. Token usage

  4. MFA compliance

Próximos Passos

Tópicos Relacionados

  • Políticas de acesso

  • Gestão de identidade

  • Automação de segurança

  • Compliance

Dica Pro: Implemente uma estratégia de autenticação em camadas, combinando diferentes métodos para maior segurança.

Melhores Práticas de Segurança no Git

Princípios Fundamentais

Pilares de Segurança

SegurançaPrevençãoDetecçãoRespostaAnáliseConfiguraçãoTreinamentoMonitoramentoAlertasAuditoriaIncidentesRecuperaçãoDocumentação

Configurações Seguras

Repositório

# Proteger branch principal
git config branch.main.protect true

# Verificar objetos na transferência
git config transfer.fsckObjects true

# Assinar commits automaticamente
git config commit.gpgsign true

Hooks de Segurança

#!/bin/sh
# pre-commit
if ! security-check; then
    echo "Falha na verificação de segurança"
    exit 1
fi

Controle de Acesso

Modelo de Permissões

Básico

Dev

Admin

Usuários

Roles

Read

Write

Admin

Clone/Pull

Push/Merge

Settings

Políticas

+------------------------+
|      POLÍTICAS        |
|                       |
| • Menor privilégio   |
| • Revisão regular    |
| • Logs de acesso     |
| • Tempo limitado     |
| • Aprovações         |
+------------------------+

Proteção de Branches

Configurações

branches:
  main:
    protection:
      required_reviews: 2
      required_checks: true
      enforce_admins: true
      linear_history: true

Workflow

Gestão de Secrets

Estratégias

Nunca

Sempre

Config

Temp

Secrets

Git

Vault

Env

Memory

Ferramentas

  1. HashiCorp Vault

  2. AWS Secrets Manager

  3. Azure Key Vault

  4. GitGuardian

  5. git-secrets

Monitoramento

Sistema de Logs

Coleta

Análise

Storage

Ação

Eventos

Logs

Alertas

Arquivo

Resposta

Métricas Importantes

+------------------------+
|      MÉTRICAS         |
|                       |
| • Tentativas acesso   |
| • Commits rejeitados  |
| • Secrets detectados  |
| • Vulnerabil

Migrando para Git

Visão Geral

MigraçãoPlanejamentoExecuçãoValidaçãoAnáliseTimelineEquipeFerramentasScriptsTestesIntegridadeHistóricoPermissões

Estratégias de Migração

Abordagens Comuns

Migração total

Por equipe

Coexistência

Big Bang

Git

Gradual

Paralelo

Checklist de Migração

Pré-Migração

  • Inventário de repositórios

  • Backup dos dados

  • Documentação do processo

  • Treinamento da equipe

Durante Migração

  • Congelamento de commits

  • Execução dos scripts

  • Validação dos dados

  • Testes de integridade

Pós-Migração

  • Verificação de acessos

  • Atualização de CI/CD

  • Documentação atualizada

  • Suporte à equipe

Ferramentas Recomendadas

Por Sistema de Origem

Próximos Passos

Tópicos Relacionados

Migrando de SVN para Git

Processo de Migração

Preparação

# Instalar git-svn
apt-get install git-svn

# Listar autores SVN
svn log -q | awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2" = "$2" <"$2">"}' | sort -u > authors.txt

Migração Básica

# Clonar repositório SVN
git svn clone --stdlayout --authors-file=authors.txt \
    http://svn.example.com/repo/ git_repo

# Otimizar repositório
cd git_repo
git gc --aggressive

Desafios Comuns

Problemas e Soluções

DesafiosBranchesHistóriaUsuáriosSVN tagsSVN externalsBranch trackingCommits grandesBináriosMergesMapeamentoPermissõesWorkflows

Validação

Checklist

Verificar

Testar

Validar

Confirmar

Commits

Integridade

Funcionalidade

Permissões

Workflows

Scripts Úteis

Mapeamento de Usuários

#!/bin/bash
# Gerar mapeamento de usuários
svn log -q | \
awk -F '|' '/^r/ {sub("^ ", "", $2); sub(" $", "", $2); print $2}' | \
sort -u > svn_users.txt

# Criar arquivo de autores
while read user; do
    echo "$user = $user <$user@example.com>"
done < svn_users.txt > authors.txt

Migração com Branches

#!/bin/bash
# Migrar com branches e tags
git svn clone \
    --stdlayout \
    --authors-file=authors.txt \
    --no-metadata \
    --prefix="svn/" \
    http://svn.example.com/repo/ \
    git_repo

Pós-Migração

Configuração Git

# Configurar remotes
git remote add origin git@github.com:org/repo.git
git push -u origin --all
git push origin --tags

# Limpar referências SVN
git config --remove-section svn-remote.svn
rm -rf .git/svn

Melhores Práticas

Recomendações

PráticasPlanejamentoExecuçãoSuporteBackupTimelineComunicaçãoTestesValidaçãoDocumentaçãoTreinamentoMonitoramentoRollback

Migrando de Mercurial para Git

Processo de Migração

Preparação

# Instalar fast-export
git clone https://github.com/frej/fast-export.git

# Preparar diretórios
mkdir git_repo
cd git_repo
git init

Migração Básica

# Executar conversão
../fast-export/hg-fast-export.sh -r /path/to/hg_repo

# Checkout do resultado
git checkout HEAD

Mapeamento de Conceitos

Equivalências

ConceitosBranchesTagsHistóricoBookmarks -&gt; BranchesNamed -&gt; BranchesDefault -&gt; MainLocal -&gt; LocalGlobal -&gt; AnnotatedChangesets -&gt; CommitsPhases -&gt; Refs

Desafios Comuns

Problemas e Soluções

Conversão

Migração

Mapeamento

Branches

Git Branches

Extensions

Git Hooks

Permissões

Git ACL

Scripts de Migração

Conversão Completa

#!/bin/bash
# Script de migração completa

# Preparar ambiente
git init git_repo
cd git_repo

# Converter repositório
/path/to/fast-export/hg-fast-export.sh \
    -r /path/to/hg_repo \
    --force

# Checkout e limpeza
git checkout HEAD
git gc --aggressive

Mapeamento de Usuários

#!/bin/bash
# Gerar mapeamento de autores
hg log | grep user: | sort -u | \
sed 's/user: *//' > authors.txt

# Criar arquivo de mapeamento
while read author; do
    echo "\"$author\"=\"$author <$author@example.com>\""
done < authors.txt > authors-map.txt

Validação

Checklist

ValidaçãoCommitsBranchesConteúdoHistóriaAutoresDatasNomesEstruturaTagsArquivosPermissõesLinks

Pós-Migração

Configuração Git

# Configurar remote
git remote add origin git@github.com:org/repo.git

# Push inicial
git push -u origin --all
git push origin --tags

# Limpar referências antigas
git gc --aggressive --prune=now

Melhores Práticas

Recomendações

+------------------------+
|    MIGRAÇÃO HG->GIT   |
|                       |
| 1. Backup completo    |
| 2. Teste piloto       |
| 3. Validação dados    |
| 4. Treinar equipe     |
| 5. Documentar processo|
+------------------------+

Dividindo Repositórios Git

Estratégias de Divisão

Abordagens

SplittingSubdirectoryHistoryReferencesgit subtreefilter-repofilter-branchBFGgit clonegit remote

Usando git-filter-repo

Processo Básico

# Instalar git-filter-repo
pip install git-filter-repo

# Extrair subdiretório
git filter-repo --path subdir/ --path-rename subdir/:

# Limpar e otimizar
git gc --aggressive --prune=now

Preservando História

Técnicas

filter-repo

Preservar

Remover

Repositório Original

Subdiretório

História

Arquivos Desnecessários

Scripts de Divisão

Extração de Subdiretório

#!/bin/bash
# Script para dividir repositório

REPO_URL="git@github.com:org/monorepo.git"
SUBDIR="projects/webapp"
NEW_REPO="webapp"

# Clonar repositório
git clone $REPO_URL
cd $(basename $REPO_URL .git)

# Extrair subdiretório
git filter-repo --path $SUBDIR/ \
    --path-rename $SUBDIR/:

# Configurar novo repositório
git remote add origin git@github.com:org/$NEW_REPO.git
git push -u origin main

Limpeza de Referências

#!/bin/bash
# Limpar referências antigas

# Remover remotes antigos
git remote remove origin

# Limpar refs
git for-each-ref --format="%(refname)" refs/original/ | \
xargs -n 1 git update-ref -d

# Executar GC
git gc --aggressive --prune=now

Validação

Checklist

Melhores Práticas

Recomendações

+------------------------+
|  DIVISÃO REPOSITÓRIO  |
|                       |
| 1. Backup inicial     |
| 2. Teste em clone     |
| 3. Validar história   |
| 4. Verificar deps     |
| 5. Atualizar CI/CD    |
+------------------------+

Mesclando Repositórios Git

Estratégias de Mesclagem

Abordagens

MergingSubtreeSubmoduleManualAddMergeAddUpdateCopyCommit

Usando git subtree

Processo Básico

# Adicionar repositório como subtree
git subtree add --prefix=subdir \
    git@github.com:org/repo.git main --squash

# Atualizar subtree
git subtree pull --prefix=subdir \
    git@github.com:org/repo.git main --squash

Preservando História

Técnicas

Merge

Merge

Preservar

Repo A

Repo Final

Repo B

História

Scripts de Mesclagem

Mesclagem com Histórico

#!/bin/bash
# Script para mesclar repositórios

REPO_A="git@github.com:org/repo-a.git"
REPO_B="git@github.com:org/repo-b.git"
FINAL_REPO="merged-repo"

# Preparar repositório final
git init $FINAL_REPO
cd $FINAL_REPO

# Adicionar e mesclar repos
git remote add -f repo-a $REPO_A
git remote add -f repo-b $REPO_B

git merge repo-a/main --allow-unrelated-histories
git merge repo-b/main --allow-unrelated-histories

Reorganização de Arquivos

#!/bin/bash
# Reorganizar estrutura após merge

# Mover arquivos
mkdir -p new/structure
git mv old/path/* new/structure/

# Commit das mudanças
git commit -m "refactor: reorganize repository structure"

# Limpar e otimizar
git gc --aggressive --prune=now

Resolução de Conflitos

Estratégias

Validação

Checklist

Verificar

Testar

Validar

Confirmar

História

Integridade

Funcionalidade

Estrutura

Referencias

Melhores Práticas

Recomendações

+------------------------+
|  MESCLAGEM REPOSITÓRIO|
|                       |
| 1. Backup repos       |
| 2. Planejar estrutura |
| 3. Testar localmente  |
| 4. Resolver conflitos |
| 5. Validar resultado  |
+------------------------+

Automação

CI/CD

#!/bin/bash
# Script de CI para validação

# Verificar estrutura
test -d "expected/path" || exit 1

# Testar funcionalidade
./run_tests.sh

# Validar referências
git fsck --full

# Verificar hooks
test -x .git/hooks/pre-commit

Troubleshooting Git

Git é uma ferramenta robusta, mas ocasionalmente problemas podem surgir. Este guia ajudará você a diagnosticar e resolver questões comuns.

Visão Geral

Categorias de Problemas

Problemas GitComunsPerformanceRepositórios GrandesRecuperaçãoConflitosPermissõesEstadoLentidãoMemóriaRedeClonesHistóricoLFSPerda dadosCorrupçãoRefs quebradas

Diagnóstico

Ferramentas Essenciais

# Verificar estado do repositório
git status

# Verificar integridade
git fsck --full

# Ver logs detalhados
GIT_TRACE=1 git comando

# Verificar objetos
git count-objects -v

Logs e Debug

+------------------------+
|    NÍVEIS DE LOG      |
|                       |
| • GIT_TRACE          |
| • GIT_TRACE_PACK     |
| • GIT_TRACE_PACKET   |
| • GIT_TRACE_PERF     |
| • GIT_TRACE_SETUP    |
+------------------------+

Prevenção

Boas Práticas

  1. Backup regular

  2. Manutenção preventiva

  3. Monitoramento

  4. Documentação

  5. Treinamento da equipe

Configurações Recomendadas

# Melhorar performance
git config core.preloadindex true
git config core.fsmonitor true

# Aumentar segurança
git config transfer.fsckObjects true

# Melhorar logs
git config core.logallrefupdates true

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um registro de problemas encontrados e suas soluções para referência futura.

Problemas Comuns do Git

Conflitos de Merge

Tipos de Conflitos

ConflitosConteúdoEstruturaMetadadosMesmo arquivoMesma linhaRenomeaçãoDeleçãoPermissõesAtributos

Resolução

# Ver arquivos em conflito
git status

# Resolver usando ferramenta
git mergetool

# Após resolver
git add .
git commit -m "resolve conflitos"

Problemas de Permissão

Diagnóstico

# Verificar permissões
ls -la .git/

# Corrigir permissões
chmod -R u+rwX .git/
chmod -R g+rwX .git/

Estados Inesperados

Problemas Comuns

+------------------------+
|    ESTADOS COMUNS     |
|                       |
| • Detached HEAD      |
| • Untracked files    |
| • Staged changes     |
| • Stash conflicts    |
| • Branch divergence  |
+------------------------+

Soluções

# Detached HEAD
git checkout -b nova-branch
git checkout main

# Limpar working directory
git clean -fd

# Desfazer alterações
git reset --hard HEAD

Problemas de Rede

Diagnóstico

# Testar conectividade
git ls-remote origin

# Debug detalhado
GIT_CURL_VERBOSE=1 git fetch

# Verificar remote
git remote -v

Problemas de Autenticação

Soluções Comuns

SSH

HTTPS

Testar

Atualizar

Erro Auth

Verificar chaves

Verificar credenciais

ssh -T Unsupported markdown: link

git credential-store

Próximos Passos

Recursos Adicionais

Dica Pro: Mantenha aliases para comandos comuns de troubleshooting no seu .gitconfig.

Problemas de Performance no Git

Diagnóstico

Métricas Importantes

PerformanceOperaçõesRecursosCloneFetchPushCPUMemóriaDiscoRede

Ferramentas de Análise

# Trace de performance
GIT_TRACE_PERFORMANCE=1 git status

# Estatísticas de objetos
git count-objects -v

# Análise de packfiles
git verify-pack -v .git/objects/pack/*.idx

Otimizações

Configurações

# Melhorar performance local
git config core.preloadindex true
git config core.fsmonitor true
git config core.untrackedCache true

# Otimizar rede
git config core.compression 9
git config pack.windowMemory "100m"

Manutenção

+------------------------+
|    MANUTENÇÃO         |
|                       |
| • git gc             |
| • git prune          |
| • git repack         |
| • git fsck           |
| • git maintenance    |
+------------------------+

Problemas Específicos

Clone Lento

# Clone raso
git clone --depth 1 URL

# Clone específico
git clone --filter=blob:none URL

# Clone parcial
git clone --sparse URL

Push/Pull Lento

Análise

Rede

Tamanho

Objetos

Problema

Causa

Compressão

LFS

GC

Monitoramento

Métricas Chave

  1. Tempo de operação

  2. Uso de recursos

  3. Tamanho do repo

  4. Objetos soltos

  5. Eficiência de pack

Comandos de Monitoramento

# Tamanho do repo
du -sh .git/

# Objetos grandes
git rev-list --objects --all | \
git cat-file --batch-check | \
sort -k3nr | head

# Status de refs
git for-each-ref --sort=-committerdate

Próximos Passos

Tópicos Relacionados

Dica Pro: Implemente monitoramento contínuo para detectar problemas de performance antes que se tornem críticos.

Gerenciando Repositórios Grandes

Estratégias

Abordagens

EstratégiasGit LFSSubmodulesPartial CloneArquivos grandesBináriosCódigo externoDependênciasHistórico parcialBlobs sob demanda

Configurações

# Configurar LFS
git lfs install
git lfs track "*.psd"

# Clone parcial
git clone --filter=blob:none URL

# Sparse checkout
git sparse-checkout set dir1 dir2

Otimização

Técnicas

+------------------------+
|    OTIMIZAÇÕES        |
|                       |
| • Git LFS            |
| • Partial clone      |
| • Shallow clone      |
| • Sparse checkout    |
| • Bfg-repo-cleaner   |
+------------------------+

Limpeza

# Remover arquivos grandes
git filter-branch --tree-filter \
'rm -rf path/to/large/file' HEAD

# Limpar histórico
git gc --aggressive --prune=now

Monitoramento

Métricas Importantes

Tamanho

Performance

Análise

Medição

Repo

.git

Operações

Objetos

Tempo

Ferramentas

# Análise de tamanho
git count-objects -vH

# Objetos grandes
git verify-pack -v .git/objects/pack/*.idx | \
sort -k 3 -n | tail -10

# Status LFS
git lfs status

Boas Práticas

Recomendações

  1. Use Git LFS para binários

  2. Implemente partial clone

  3. Mantenha histórico limpo

  4. Monitore crescimento

  5. Documente políticas

Manutenção Regular

# Limpeza periódica
git maintenance start

# Verificação
git fsck --full

# Compactação
git repack -ad

Próximos Passos

Tópicos Relacionados

Dica Pro: Estabeleça políticas claras para gerenciamento de arquivos grandes antes que o repositório cresça demais.

Procedimentos de Recuperação

Recuperação de Dados

Ferramentas

RecuperaçãoReflogFSckStashCommitsBranchesObjetosIntegridadeWIPTemporário

Comandos Básicos

# Ver reflog
git reflog

# Verificar objetos
git fsck --full

# Recuperar stash
git stash list
git stash apply

Corrupção de Repositório

Diagnóstico

+------------------------+
|    DIAGNÓSTICO        |
|                       |
| • Objetos perdidos   |
| • Refs quebradas     |
| • Index corrompido   |
| • Pack corrompido    |
| • HEAD inválido      |
+------------------------+

Reparação

# Verificar e reparar
git fsck --full

# Reparar refs
git gc --prune=now

# Recriar index
rm .git/index
git reset

Recuperação de Commits

Técnicas

Reflog

Reset

Branch

Commit Perdido

Recuperar Hash

Restaurar Estado

Salvar Mudanças

Procedimentos

# Encontrar commit
git reflog show --all

# Criar branch
git branch recovery-branch HASH

# Reset para commit
git reset --hard HASH

Backup e Prevenção

Estratégias

  1. Backup regular

  2. Mirrors remotos

  3. Bundle backups

  4. Documentação

  5. Testes de recuperação

Comandos de Backup

# Criar bundle
git bundle create repo.bundle --all

# Mirror completo
git clone --mirror URL

# Backup refs
git for-each-ref > refs_backup.txt

Plano de Recuperação

Passos

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um plano de recuperação documentado e testado regularmente para minimizar tempo de recuperação em emergências.

GitLab: Visão Geral

+------------------------+
|        GitLab         |
|                       |
| DevOps Completo       |
| Ciclo de Vida         |
| Colaboração           |
|                       |
| Tudo em Um            |
+------------------------+

O que é GitLab?

O GitLab é uma plataforma DevOps completa, entregue como uma única aplicação. Ele abrange todo o ciclo de vida DevOps, permitindo que equipes colaborem, desenvolvam, testem, implantem e monitorem aplicações em um único ambiente.

GitLabSCMCI/CDPlanejamentoSegurançaMonitoramentoGitBranchesMRsPipelinesRunnersEnvironmentsIssuesBoardsMilestonesSASTDASTDependency ScanningMetricsLogsAlerts

Edições do GitLab

Comparação

+------------------------+
|      EDIÇÕES          |
|                       |
| • Community Edition   |
|   - Open Source       |
|   - Gratuito          |
|                       |
| • Enterprise Edition  |
|   - Comercial         |
|   - Recursos extras   |
|                       |
| • SaaS (gitlab.com)   |
|   - Hospedado         |
|   - Planos variados   |
+------------------------+

Recursos por Edição

GitLab

CE

EE

Recursos Básicos

Recursos Enterprise

Governança

Segurança Avançada

Gerenciamento

Arquitetura

Componentes

Serviços

+------------------------+
|     COMPONENTES       |
|                       |
| • Nginx               |
| • Unicorn/Puma        |
| • Sidekiq             |
| • Redis               |
| • PostgreSQL          |
| • Gitaly              |
| • GitLab Workhorse    |
| • GitLab Shell        |
+------------------------+

Principais Recursos

Gerenciamento de Código

  • Repositórios Git

  • Merge Requests

  • Code Review

  • Web IDE

  • Snippets

CI/CD

EnvPipelineDevEnvPipelineDevPush codeBuildTestSecurity ScanDeploy

Planejamento e Monitoramento

  • Issues

  • Boards

  • Milestones

  • Epics (EE)

  • Roadmaps (EE)

  • Métricas e Analytics

Comparação com Outras Plataformas

GitLab vs GitHub

+------------------------+
|   GitLab vs GitHub    |
|                       |
| GitLab:               |
| • DevOps completo     |
| • CI/CD integrado     |
| • Self-hosted fácil   |
|                       |
| GitHub:               |
| • Maior comunidade    |
| • Actions             |
| • Melhor UX           |
+------------------------+

GitLab vs Bitbucket

ComparaçãoGitLabBitbucketDevOps completoCI/CD nativoCommunity EditionIntegração JiraPipelinesData Center

Próximos Passos

Tópicos Relacionados

Dica Pro: O GitLab oferece uma experiência DevOps completa, mas comece com os recursos básicos e vá expandindo conforme sua equipe se familiariza com a plataforma.

Instalação do GitLab

+------------------------+
|  GitLab Installation  |
|                       |
| Self-Hosted           |
| Omnibus Package       |
| Docker                |
| Kubernetes            |
|                       |
| Múltiplas Opções      |
+------------------------+

Por que Instalar o GitLab Self-Hosted?

Embora o GitLab.com ofereça uma solução hospedada pronta para uso, existem várias razões convincentes para optar por uma instalação self-hosted:

Vantagens do Self-Hosted

GitLab Self-HostedControlePersonalizaçãoSegurançaCustoDadosInfraestruturaAtualizaçõesConfiguraçõesIntegraçõesHardwareIsolamentoCompliancePolíticas internasLicenciamentoEconomia em escala

Casos de Uso Específicos

  • Requisitos de Compliance: Organizações em setores regulamentados (finanças, saúde, governo) precisam manter dados sensíveis em suas próprias infraestruturas.

  • Ambientes Air-Gapped: Redes isoladas sem acesso à internet exigem soluções locais.

  • Personalização Avançada: Necessidade de integração profunda com sistemas internos e fluxos de trabalho específicos.

  • Performance: Controle sobre recursos de hardware para otimizar desempenho em grandes instalações.

  • Latência Reduzida: Instalação próxima aos desenvolvedores para operações Git mais rápidas.

+------------------------+
|   QUANDO ESCOLHER     |
|                       |
| • Dados sensíveis     |
| • Muitos usuários     |
| • Integração interna  |
| • Controle total      |
| • Compliance          |
| • Redes isoladas      |
+------------------------+

Requisitos de Sistema

Hardware Recomendado

+------------------------+
|    HARDWARE MÍNIMO    |
|                       |
| • 4 CPU cores         |
| • 8GB RAM             |
| • 40GB armazenamento  |
|                       |
|    RECOMENDADO        |
|                       |
| • 8+ CPU cores        |
| • 16GB+ RAM           |
| • SSD 100GB+          |
+------------------------+

Software Necessário

  • Sistema operacional Linux (Ubuntu, Debian, CentOS)

  • Postfix para envio de emails

  • Acesso root ou sudo

Métodos de Instalação

Omnibus Package (Recomendado)

Preparação

Instalação

Configuração

Inicialização

Pós-instalação

Ubuntu/Debian

# Adicionar repositório GitLab
curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash

# Instalar GitLab CE
sudo apt install gitlab-ce

# Configurar e iniciar
sudo gitlab-ctl reconfigure

CentOS/RHEL

# Adicionar repositório GitLab
curl -sS https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | sudo bash

# Instalar GitLab CE
sudo yum install gitlab-ce

# Configurar e iniciar
sudo gitlab-ctl reconfigure

Docker

# Executar GitLab CE
docker run --detach \
  --hostname gitlab.exemplo.com \
  --publish 443:443 --publish 80:80 --publish 22:22 \
  --name gitlab \
  --restart always \
  --volume $GITLAB_HOME/config:/etc/gitlab \
  --volume $GITLAB_HOME/logs:/var/log/gitlab \
  --volume $GITLAB_HOME/data:/var/opt/gitlab \
  gitlab/gitlab-ce:latest

Docker Compose

# docker-compose.yml
version: '3.7'
services:
  gitlab:
    image: 'gitlab/gitlab-ce:latest'
    restart: always
    hostname: 'gitlab.exemplo.com'
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'https://gitlab.exemplo.com'
    ports:
      - '80:80'
      - '443:443'
      - '22:22'
    volumes:
      - '$GITLAB_HOME/config:/etc/gitlab'
      - '$GITLAB_HOME/logs:/var/log/gitlab'
      - '$GITLAB_HOME/data:/var/opt/gitlab'

Kubernetes (Helm)

# Adicionar repositório Helm
helm repo add gitlab https://charts.gitlab.io/

# Instalar GitLab
helm install gitlab gitlab/gitlab \
  --set global.hosts.domain=exemplo.com \
  --set global.hosts.externalIP=XX.XX.XX.XX \
  --set certmanager-issuer.email=admin@exemplo.com

Configuração Inicial

Primeiro Acesso

  1. Acesse http://gitlab.exemplo.com (ou o endereço configurado)

  2. Defina a senha para o usuário root

  3. Faça login com usuário root e a senha definida

Configuração de Email

# /etc/gitlab/gitlab.rb
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.gmail.com"
gitlab_rails['smtp_port'] = 587
gitlab_rails['smtp_user_name'] = "seu-email@gmail.com"
gitlab_rails['smtp_password'] = "sua-senha"
gitlab_rails['smtp_domain'] = "gmail.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['gitlab_email_from'] = 'gitlab@exemplo.com'

Após editar, aplique as alterações:

sudo gitlab-ctl reconfigure

Atualizações

Omnibus Package

# Backup antes de atualizar
sudo gitlab-backup create

# Atualizar pacotes
sudo apt update
sudo apt upgrade gitlab-ce

# Aplicar alterações
sudo gitlab-ctl reconfigure

Docker

# Puxar nova imagem
docker pull gitlab/gitlab-ce:latest

# Parar e remover container atual
docker stop gitlab
docker rm gitlab

# Iniciar novo container
docker run --detach \
  --hostname gitlab.exemplo.com \
  --publish 443:443 --publish 80:80 --publish 22:22 \
  --name gitlab \
  --restart always \
  --volume $GITLAB_HOME/config:/etc/gitlab \
  --volume $GITLAB_HOME/logs:/var/log/gitlab \
  --volume $GITLAB_HOME/data:/var/opt/gitlab \
  gitlab/gitlab-ce:latest

Troubleshooting

Problemas Comuns

ProblemasConexãoPerformanceServiçosPortasFirewallProxyCPURAMDiscoNginxUnicorn/PumaSidekiq

Comandos Úteis

# Verificar status
sudo gitlab-ctl status

# Ver logs
sudo gitlab-ctl tail

# Verificar configuração
sudo gitlab-rake gitlab:check

# Reparar permissões
sudo gitlab-ctl reconfigure

# Reiniciar serviços
sudo gitlab-ctl restart

Instalações Especializadas

Alta Disponibilidade

+------------------------+
|  ALTA DISPONIBILIDADE |
|                       |
| • PostgreSQL replicado|
| • Redis redundante    |
| • Load balancer       |
| • Storage compartilhado|
| • Geo replication     |
+------------------------+

Geo Replication

Replica

Acesso

Acesso

GitLab Primário

GitLab Secundário

Usuários Região 1

Usuários Região 2

GitLab.com vs Self-Hosted

Comparação

+------------------------+
|     GITLAB.COM        |
| • Rápido para começar |
| • Sem manutenção      |
| • Atualizações auto.  |
| • Planos gratuitos    |
|                       |
|     SELF-HOSTED       |
| • Controle total      |
| • Personalização      |
| • Segurança interna   |
| • Integração local    |
+------------------------+

Quando Migrar para Self-Hosted

  • Quando sua equipe ultrapassar 100 usuários (potencial economia de custos)

  • Quando requisitos de compliance exigirem controle total dos dados

  • Quando precisar de integrações profundas com sistemas internos

  • Quando a performance se tornar crítica para grandes repositórios

Próximos Passos

Tópicos Relacionados

Dica Pro: Para ambientes de produção, sempre dimensione os recursos de acordo com o número de usuários e repositórios esperados. O GitLab pode consumir muitos recursos em instalações maiores.

Configuração do GitLab

+------------------------+
| GitLab Configuration  |
|                       |
| Personalização        |
| Integração            |
| Segurança             |
| Performance           |
|                       |
| Adaptação Completa    |
+------------------------+

Configuração Básica

Arquivo de Configuração Principal

O arquivo principal de configuração do GitLab é o /etc/gitlab/gitlab.rb para instalações Omnibus. Todas as configurações são centralizadas neste arquivo.

# Editar configuração
sudo vim /etc/gitlab/gitlab.rb

# Aplicar alterações
sudo gitlab-ctl reconfigure

URL Externa

# /etc/gitlab/gitlab.rb
external_url 'https://gitlab.exemplo.com'

Configurações de HTTPS

# /etc/gitlab/gitlab.rb
# Habilitar HTTPS
external_url 'https://gitlab.exemplo.com'
nginx['redirect_http_to_https'] = true

# Certificados Let's Encrypt
letsencrypt['enable'] = true
letsencrypt['contact_emails'] = ['admin@exemplo.com']

# Certificados personalizados
nginx['ssl_certificate'] = "/etc/gitlab/ssl/gitlab.exemplo.com.crt"
nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/gitlab.exemplo.com.key"

Personalização da Interface

Logo e Aparência

# /etc/gitlab/gitlab.rb
gitlab_rails['gitlab_logo'] = 'logo.png'
gitlab_rails['gitlab_favicon'] = 'favicon.ico'

# Cores e estilo
gitlab_rails['brand_primary_color'] = '#1d75b3'
gitlab_rails['brand_secondary_color'] = '#107a10'

Página de Login

# /etc/gitlab/gitlab.rb
gitlab_rails['gitlab_signin_enabled'] = true
gitlab_rails['gitlab_signin_text'] = 'Bem-vindo ao GitLab da Empresa XYZ'

Configuração de Email

SMTP

# /etc/gitlab/gitlab.rb
gitlab_rails['smtp_enable'] = true
gitlab_rails['smtp_address'] = "smtp.office365.com"
gitlab_rails['smtp_port'] = 587
gitlab_rails['smtp_user_name'] = "gitlab@empresa.com"
gitlab_rails['smtp_password'] = "senha-segura"
gitlab_rails['smtp_domain'] = "empresa.com"
gitlab_rails['smtp_authentication'] = "login"
gitlab_rails['smtp_enable_starttls_auto'] = true
gitlab_rails['gitlab_email_from'] = 'gitlab@empresa.com'
gitlab_rails['gitlab_email_reply_to'] = 'noreply@empresa.com'

Testando Configuração de Email

# Testar configuração de email
sudo gitlab-rails console

# No console Rails
Notify.test_email('seu-email@exemplo.com', 'Assunto', 'Corpo').deliver_now

Autenticação e Autorização

LDAP

# /etc/gitlab/gitlab.rb
gitlab_rails['ldap_enabled'] = true
gitlab_rails['ldap_servers'] = {
  'main' => {
    'label' => 'LDAP Corporativo',
    'host' =>  'ldap.empresa.com',
    'port' => 389,
    'uid' => 'sAMAccountName',
    'encryption' => 'plain',
    'bind_dn' => 'CN=GitLab,OU=Service Accounts,DC=empresa,DC=com',
    'password' => 'senha-ldap',
    'active_directory' => true,
    'base' => 'OU=Users,DC=empresa,DC=com',
    'user_filter' => ''
  }
}

OAuth (Google, GitHub, etc)

# /etc/gitlab/gitlab.rb
gitlab_rails['omniauth_enabled'] = true
gitlab_rails['omniauth_allow_single_sign_on'] = ['google_oauth2', 'github']
gitlab_rails['omniauth_block_auto_created_users'] = false
gitlab_rails['omniauth_providers'] = [
  {
    "name" => "google_oauth2",
    "app_id" => "YOUR_APP_ID",
    "app_secret" => "YOUR_APP_SECRET",
    "args" => { "access_type" => "offline", "approval_prompt" => "" }
  },
  {
    "name" => "github",
    "app_id" => "YOUR_APP_ID",
    "app_secret" => "YOUR_APP_SECRET",
    "args" => { "scope" => "user:email" }
  }
]

Configuração de Armazenamento

Armazenamento de Objetos (S3)

# /etc/gitlab/gitlab.rb
gitlab_rails['object_store']['enabled'] = true
gitlab_rails['object_store']['connection'] = {
  'provider' => 'AWS',
  'region' => 'us-east-1',
  'aws_access_key_id' => 'SUA_ACCESS_KEY',
  'aws_secret_access_key' => 'SUA_SECRET_KEY',
  'endpoint' => 'https://s3.amazonaws.com'
}

# Configurar LFS, Artifacts, Uploads, etc
gitlab_rails['lfs_object_store_enabled'] = true
gitlab_rails['lfs_object_store_remote_directory'] = 'gitlab-lfs-objects'

Configuração de Backup

# /etc/gitlab/gitlab.rb
gitlab_rails['backup_path'] = "/var/opt/gitlab/backups"
gitlab_rails['backup_archive_permissions'] = 0644
gitlab_rails['backup_keep_time'] = 604800  # 7 dias em segundos

Configuração de Performance

Recursos do Sistema

# /etc/gitlab/gitlab.rb
puma['worker_processes'] = 4
puma['max_threads'] = 4
postgresql['shared_buffers'] = "2GB"
postgresql['work_mem'] = "128MB"

Caching com Redis

# /etc/gitlab/gitlab.rb
gitlab_rails['redis_cache_instance'] = "redis://:password@redis-cache.example.com:6379/0"
gitlab_rails['redis_queues_instance'] = "redis://:password@redis-queues.example.com:6379/0"
gitlab_rails['redis_shared_state_instance'] = "redis://:password@redis-shared-state.example.com:6379/0"

Configuração de Segurança

Restrições de Registro

# /etc/gitlab/gitlab.rb
gitlab_rails['gitlab_signup_enabled'] = false
gitlab_rails['gitlab_signin_enabled'] = true
gitlab_rails['gitlab_restricted_visibility_levels'] = ['public']
gitlab_rails['gitlab_default_projects_features_issues'] = true

Configuração de Firewall

# Configurar firewall (Ubuntu/Debian)
sudo ufw allow http
sudo ufw allow https
sudo ufw allow OpenSSH

# Verificar regras
sudo ufw status

Monitoramento e Logs

Prometheus e Grafana

# /etc/gitlab/gitlab.rb
prometheus['enable'] = true
grafana['enable'] = true
grafana['admin_password'] = 'senha-segura'

Configuração de Logs

# /etc/gitlab/gitlab.rb
logging['logrotate_frequency'] = "daily"
logging['logrotate_size'] = "10M"
logging['logrotate_rotate'] = 30

Integração com Runners

Registro de Runner

# Instalar GitLab Runner
curl -L https://packages.gitlab.com/install/repositories/runner/gitlab-runner/script.deb.sh | sudo bash
sudo apt-get install gitlab-runner

# Registrar Runner
sudo gitlab-runner register

Configuração de Runner

# /etc/gitlab-runner/config.toml
[[runners]]
  name = "docker-runner"
  url = "https://gitlab.exemplo.com"
  token = "TOKEN"
  executor = "docker"
  [runners.docker]
    tls_verify = false
    image = "docker:latest"
    privileged = true

Configurações Avançadas

Alta Disponibilidade

# /etc/gitlab/gitlab.rb no nó primário
roles ['redis_master', 'redis_sentinel', 'postgres_master', 'pgbouncer', 'consul_server']
postgresql['listen_address'] = '0.0.0.0'
redis['bind'] = '0.0.0.0'

Geo Replication

# /etc/gitlab/gitlab.rb no nó primário
gitlab_rails['geo_primary_role'] = true

# /etc/gitlab/gitlab.rb no nó secundário
gitlab_rails['geo_secondary_role'] = true
gitlab_rails['geo_secondary_name'] = 'secondary-site'
gitlab_rails['geo_node_name'] = 'secondary-site'

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um ambiente de teste para validar alterações de configuração antes de aplicá-las em produção. Sempre faça backup antes de grandes mudanças.

Configuração SSH no GitLab

+------------------------+
|    GitLab SSH Setup   |
|                       |
| Autenticação Segura   |
| Sem Senhas            |
| Clonagem Rápida       |
|                       |
| Acesso Simplificado   |
+------------------------+

Por que usar SSH?

O SSH (Secure Shell) permite que você se conecte e autentique em servidores remotos, como o GitLab, de forma segura sem precisar digitar sua senha a cada operação.

GitLabLocalUsuárioGitLabLocalUsuárioGera chave SSHAdiciona chave públicagit push/pullVerifica chaveAutenticado!

Gerando Chaves SSH

No Linux/macOS

# Gerar nova chave ED25519 (recomendado)
ssh-keygen -t ed25519 -C "seu.email@exemplo.com"

# Ou gerar RSA (compatibilidade)
ssh-keygen -t rsa -b 4096 -C "seu.email@exemplo.com"

No Windows

# Com Git Bash
ssh-keygen -t ed25519 -C "seu.email@exemplo.com"

# Com PowerShell (OpenSSH)
ssh-keygen -t ed25519 -C "seu.email@exemplo.com"

Adicionando Chave ao SSH Agent

Linux/macOS

# Iniciar o ssh-agent
eval "$(ssh-agent -s)"

# Adicionar chave
ssh-add ~/.ssh/id_ed25519

Windows

# Git Bash
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# PowerShell
# Iniciar o serviço
Start-Service ssh-agent
# Adicionar chave
ssh-add $env:USERPROFILE\.ssh\id_ed25519

Adicionando Chave ao GitLab

Copiando a Chave Pública

# Linux/macOS
cat ~/.ssh/id_ed25519.pub | pbcopy  # macOS
cat ~/.ssh/id_ed25519.pub | xclip -selection clipboard  # Linux

# Windows
cat ~/.ssh/id_ed25519.pub | clip

Passos no GitLab

  1. Faça login no GitLab

  2. Clique no seu avatar (canto superior direito)

  3. Selecione "Preferences"

  4. Navegue até "SSH Keys"

  5. Cole sua chave pública

  6. Adicione um título descritivo (ex: "Laptop Trabalho")

  7. Clique em "Add key"

Login

Avatar

Preferences

SSH Keys

Add Key

Title + Key

Add Key Button

Testando a Conexão

# Testar conexão SSH com GitLab
ssh -T git@gitlab.com

# Resposta esperada
# Welcome to GitLab, @username!

Usando SSH com Repositórios

Clonando via SSH

# Clonar repositório
git clone git@gitlab.com:grupo/projeto.git

# Verificar remote
git remote -v

Alterando Repositório Existente

# Mudar de HTTPS para SSH
git remote set-url origin git@gitlab.com:grupo/projeto.git

Configurações Avançadas

Múltiplas Chaves

# ~/.ssh/config
Host gitlab.com
  HostName gitlab.com
  User git
  IdentityFile ~/.ssh/gitlab_key
  IdentitiesOnly yes

Host gitlab-trabalho
  HostName gitlab.trabalho.com
  User git
  IdentityFile ~/.ssh/trabalho_key
  IdentitiesOnly yes

Segurança Adicional

# Proteger chave com passphrase
ssh-keygen -t ed25519 -C "seu.email@exemplo.com" -o -a 100

# Usar ssh-agent para armazenar passphrase
ssh-add ~/.ssh/id_ed25519

Troubleshooting

Problemas Comuns

Soluções

# Verificar permissões
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_ed25519
chmod 644 ~/.ssh/id_ed25519.pub

# Debug de conexão
ssh -vT git@gitlab.com

# Verificar chaves carregadas
ssh-add -l

Boas Práticas

Segurança

+------------------------+
|    BOAS PRÁTICAS      |
|                       |
| • Use ED25519         |
| • Adicione passphrase |
| • Backup seguro       |
| • Revogue se perdida  |
| • Renove anualmente   |
+------------------------+

Organização

# Nomenclatura clara
id_ed25519_gitlab_pessoal
id_ed25519_gitlab_trabalho

# Comentários descritivos
ssh-keygen -t ed25519 -C "Laptop Pessoal - GitLab"

Próximos Passos

Tópicos Relacionados

Dica Pro: Configure o SSH uma vez e esqueça senhas para sempre. Seu fluxo de trabalho com Git ficará muito mais rápido e seguro.

Convenções de Commit

Estrutura Básica

<tipo>(<escopo>): <descrição>

[corpo opcional]

[rodapé opcional]

Tipos de Commit

Principais Categorias

  • feat: Nova funcionalidade

  • fix: Correção de bug

  • docs: Documentação

  • style: Formatação

  • refactor: Refatoração

  • test: Testes

  • chore: Tarefas gerais

Boas Práticas

Mensagens

  • Use modo imperativo

  • Mantenha até 50 caracteres no título

  • Limite linhas do corpo em 72 caracteres

  • Seja claro e conciso

Exemplos

feat(auth): adiciona autenticação OAuth
fix(api): corrige timeout em requisições longas
docs(readme): atualiza instruções de instalação

Ferramentas

Commitlint

{
  "extends": ["@commitlint/config-conventional"],
  "rules": {
    "type-enum": [2, "always", ["feat", "fix", "docs"]]
  }
}

Commitizen

# Instalação
npm install -g commitizen
npm install -g cz-conventional-changelog

# Uso
git cz

Automação

Git Hooks

#!/bin/sh
# .git/hooks/commit-msg

commit_msg=$(cat "$1")
if ! echo "$commit_msg" | grep -qE "^(feat|fix|docs|style|refactor|test|chore):"; then
    echo "Erro: Mensagem não segue convenção"
    exit 1
fi

Integração com CI

Validação Automática

name: Commit Check
on: [push, pull_request]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Commit Linter
        uses: wagoid/commitlint-github-action@v5

Estratégias de Branch

Modelos Principais

GitFlow

main

develop

feature/1

feature/2

release/1.0

hotfix

Trunk-Based

main

feature/1

feature/2

Nomenclatura

Padrões

feature/   - Novas funcionalidades
fix/       - Correções de bugs
hotfix/    - Correções urgentes
release/   - Preparação para release
docs/      - Documentação
refactor/  - Refatoração

Proteções

Regras de Branch

branches:
  main:
    protection:
      required_reviews: 2
      required_checks: true
      enforce_admins: true

Fluxo de Trabalho

Feature Branch

  1. Criar branch da main

  2. Desenvolver feature

  3. Criar Pull Request

  4. Code Review

  5. Merge após aprovação

Hotfix

  1. Branch da main

  2. Correção rápida

  3. Merge direto para main

  4. Sincronizar develop

Automação

GitHub Actions

name: Branch Protection
on:
  pull_request:
    branches: [main]
jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run Tests
        run: npm test

Práticas de Code Review

Princípios Fundamentais

Objetivos

  • Qualidade de código

  • Compartilhamento de conhecimento

  • Consistência

  • Detecção precoce de bugs

Processo

Fluxo de Review

Submit PR

Automated Checks

Code Review

Discussion

Changes

Approval

Merge

Checklist

Aspectos Técnicos

✓ Funcionalidade
  └─ Atende requisitos
  └─ Casos de borda
  └─ Tratamento de erros

✓ Código
  └─ Legibilidade
  └─ Manutenibilidade
  └─ Performance
  └─ Segurança

✓ Testes
  └─ Cobertura
  └─ Qualidade
  └─ Casos relevantes

Feedback

Boas Práticas

  • Seja construtivo

  • Foque no código, não no autor

  • Explique o "porquê"

  • Sugira melhorias

  • Use exemplos

Formato

### Feedback Template

**Contexto**
- Arquivo/função em questão

**Observação**
- Descrição clara do ponto

**Sugestão**
- Proposta de melhoria

**Exemplo**
```código sugerido```

Automação

GitHub Actions

name: Code Review
on: [pull_request]
jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Code Analysis
        uses: github/codeql-action/analyze@v2

Práticas de Documentação

Estrutura

Hierarquia

docs/
├── README.md
├── CONTRIBUTING.md
├── CHANGELOG.md
└── technical/
    ├── architecture.md
    ├── api.md
    └── deployment.md

Componentes Essenciais

README

# Projeto XYZ

## Visão Geral
Breve descrição do projeto

## Instalação
```bash
npm install
npm start

Uso

Exemplos básicos

Contribuição

Como contribuir

Licença

MIT

## Documentação Técnica

### API
```yaml
/users:
  get:
    description: Lista usuários
    parameters:
      - name: limit
        type: integer
    responses:
      200:
        description: Sucesso

Arquitetura

Frontend

API

Database

Cache

Automação

Geração de Docs

name: Docs
on:
  push:
    branches: [main]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Build Docs
        run: |
          npm install
          npm run docs

Manutenção

Checklist

  • Atualizar após mudanças

  • Revisar periodicamente

  • Validar exemplos

  • Manter changelog

  • Verificar links

Colaboração em Equipe

Comunicação

Canais

ComunicaçãoAssíncronaSíncronaIssuesPRsDocsDailyPlanningReview

Processos

Workflow

Planning

Development

Review

QA

Deploy

Ferramentas

Stack Essencial

Colaboração
├── Git
├── GitHub/GitLab
└── CI/CD

Comunicação
├── Slack/Teams
├── Jira/Trello
└── Confluence/Wiki

Desenvolvimento
├── IDE
├── Linters
└── Testing

Boas Práticas

Code Review

  • Revisões regulares

  • Feedback construtivo

  • Compartilhamento de conhecimento

  • Documentação de decisões

Pair Programming

Driver

Navigator

Gestão de Conflitos

Resolução

  1. Identificar conflito

  2. Discutir alternativas

  3. Decidir solução

  4. Documentar decisão

Git Conflicts

# Resolver conflitos
git checkout feature
git rebase main
git mergetool

Métricas

KPIs

📊 Métricas Chave
├── Tempo de Review
├── Taxa de Bugs
├── Cobertura de Testes
└── Velocidade de Deploy

Integração Contínua

Pipeline Básico

Estrutura

Trigger

Commit

Build

Test

Lint

Deploy

Configuração

GitHub Actions

name: CI
on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup
        run: npm install
      - name: Build
        run: npm run build
      - name: Test
        run: npm test

Automação

Scripts

#!/bin/sh
# build.sh
npm install
npm run lint
npm test
npm run build

Qualidade

Checks

✓ Lint
  └─ Estilo
  └─ Padrões
  └─ Boas práticas

✓ Testes
  └─ Unitários
  └─ Integração
  └─ E2E

✓ Build
  └─ Compilação
  └─ Bundling
  └─ Otimização

Monitoramento

Métricas

CIBuildTestesDeployTempoSucessoFalhasCoberturaPerformanceFrequênciaRollbacks

Segurança

Scans

security:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v3
    - name: Security Scan
      uses: snyk/actions/node@master
    - name: SAST
      uses: github/codeql-action/analyze@v2

Gerenciamento de Monorepo

O que é um Monorepo?

Um monorepo é um repositório único que contém múltiplos projetos relacionados, com possíveis diferentes linguagens de programação, ferramentas e releases independentes.

Estrutura Básica

monorepo/
├── packages/
│   ├── frontend/
│   ├── backend/
│   └── shared/
├── tools/
├── docs/
└── scripts/

Ferramentas Populares

Gerenciadores de Workspace

FerramentasLernaNxTurborepoBazelVersioningPublishingBuild SystemCachingTask PipelineRemote CacheGoogle ScaleMulti-language

Vantagens e Desvantagens

Prós

  • Código compartilhado

  • Refatoração atômica

  • Consistência de versões

  • Colaboração simplificada

Contras

  • Build mais complexo

  • CI/CD mais lento

  • Git mais pesado

  • Curva de aprendizado

Melhores Práticas

1. Organização

Packages

Tools

Docs

Monorepo

Módulos

Ferramentas

Documentação

Dependências

Scripts

2. Performance

# Shallow clone
git clone --depth 1 

# Sparse checkout
git sparse-checkout set packages/frontend

# Partial clone
git clone --filter=blob:none

CI/CD para Monorepos

Pipeline Básico

Affected

Success

Pass

Detect Changes

Build

Test

Deploy

Configuração

build:
  script:
    - nx affected:build
    - nx affected:test
    - nx affected:lint

Escalabilidade

Estratégias

  1. Cache distribuído

  2. Build incremental

  3. Testes paralelos

  4. Deploy seletivo

Monitoramento

MétricasBuildGitCITempoCache hitsClone timeSizePipelineResources

Troubleshooting

Problemas Comuns

IssuesPerformanceDependênciasCI/CDBuild lentoGit pesadoConflitosVersõesCachePipeline

Próximos Passos

Tópicos Relacionados

Dica Pro: Use ferramentas como git maintenance e git gc regularmente para manter o repositório otimizado.

Workflow Open Source

Visão Geral

O workflow open source é um modelo colaborativo que permite contribuições de múltiplos desenvolvedores, mantendo qualidade e organização.

Estrutura do Projeto

Arquivos Essenciais

projeto/
├── README.md
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── LICENSE
└── .github/
    ├── ISSUE_TEMPLATE/
    └── PULL_REQUEST_TEMPLATE.md

Processo de Contribuição

Fluxo Básico

Clone

Branch

Commit

Pull Request

Merge

Fork

Local

Desenvolvimento

Push

Review

Upstream

Guidelines

1. Commits

# Formato
<tipo>(<escopo>): <descrição>

# Exemplos
feat(auth): adiciona autenticação OAuth
fix(api): corrige erro na validação
docs(readme): atualiza instruções de instalação

2. Issues

IssuesBugFeatureQuestionReproduçãoLogsPropostaBenefíciosContextoDúvida

Code Review

Processo

Manutenção

Tarefas Regulares

ManutençãoIssuesPRsReleasesDocsTriageLabelsReviewMergeVersioningNotesUpdateTranslate

Automação

GitHub Actions

name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run tests
        run: |
          npm install
          npm test

Comunicação

Canais

+------------------------+
|     COMUNICAÇÃO       |
|                       |
| • Issues             |
| • Discussions       |
| • Discord           |
| • Mailing List      |
| • Blog              |
+------------------------+

Releases

Processo

Feature Freeze

Testing

Feedback

Tag

Develop

Release Branch

RC

Final

Release

Métricas

KPIs

MétricasContribuiçõesComunidadeQualidadePRsIssuesStarsForksTestsCoverage

Próximos Passos

Tópicos Relacionados

Dica Pro: Mantenha um changelog detalhado e use semantic versioning para facilitar o acompanhamento das mudanças.

Git Empresarial

Características

O Git em ambiente empresarial requer considerações especiais de segurança, escalabilidade e governança.

Infraestrutura

Arquitetura

HTTPS/SSH

Auth

Storage

Backup

Git Server

Load Balancer

LDAP/SSO

HA Storage

Backup System

Segurança

Políticas

SegurançaAcessoCódigoAuditoria2FASSOSigningScanningLogsCompliance

Configurações

# Força HTTPS
git config --global http.sslVerify true

# Signing commits
git config --global commit.gpgsign true

# Credentials timeout
git config --global credential.helper 'cache --timeout=3600'

Governança

Estrutura

+------------------------+
|     GOVERNANÇA        |
|                       |
| • Políticas         |
| • Padrões          |
| • Compliance       |
| • Auditoria        |
| • Treinamento      |
+------------------------+

Integração

Sistemas Corporativos

Workflows

Branching Strategy

maindevelopfeature0-f7d31411-96568632-e995d2f5-e7e71a7v1.0

Performance

Otimizações

PerformanceServerClientNetworkLoad BalancingCachingShallow CloneSparse CheckoutCompressionProxy

Backup e DR

Estratégias

  1. Backup incremental

  2. Replicação geográfica

  3. Snapshot periódico

  4. Teste de recuperação

Configuração

# Backup script
#!/bin/bash
DATE=$(date +%Y%m%d)
git bundle create backup-$DATE.bundle --all

Monitoramento

Métricas Principais

MonitoringSistemaGitNetworkCPUMemóriaReposUsersLatênciaThroughput

Compliance

Requisitos

+------------------------+
|     COMPLIANCE        |
|                       |
| • SOX               |
| • GDPR              |
| • ISO 27001         |
| • PCI DSS           |
| • HIPAA             |
+------------------------+

Próximos Passos

Tópicos Relacionados

Dica Pro: Implemente hooks de servidor para forçar políticas de segurança e qualidade de código.

Git e DevOps

Integração Contínua

Pipeline Básico

Trigger

Success

Pass

Success

Git Push

Build

Test

Deploy

Monitor

Automação

GitHub Actions

name: CI/CD
on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        run: make build
      - name: Test
        run: make test
      - name: Deploy
        if: github.ref == 'refs/heads/main'
        run: make deploy

Infrastructure as Code

Git + IaC

IaCTerraformAnsibleKubernetesStateModulesPlaybooksRolesManifestsHelm

Monitoramento

Métricas DevOps

Git

Código

Métricas

Lead Time

Deploy Frequency

MTTR

Change Failure

Segurança

DevSecOps

+------------------------+
|     SEGURANÇA         |
|                       |
| • SAST              |
| • DAST              |
| • SCA               |
| • IAST              |
| • Secrets Scan      |
+------------------------+

Deployment

Estratégias

DeployBlue/GreenCanaryRollingZero downtimeQuick rollbackGradualMonitoredContinuousResource efficient

Ferramentas

Stack DevOps

Source

Build

Deploy

Monitor

Git

Jenkins/GitLab CI

Docker

Kubernetes

Prometheus

Boas Práticas

Guidelines

  1. Trunk-based development

  2. Feature flags

  3. Automated testing

  4. Continuous feedback

  5. Infrastructure as Code

Workflow

ProdCI/CDGitDevProdCI/CDGitDevPushTriggerBuild & TestDeploy

Observabilidade

Componentes

ObservabilityLogsMétricasTracesELKSplunkPrometheusGrafanaJaegerZipkin

Recuperação

Disaster Recovery

Detect

Analyze

Fix

Learn

Incident

Alert

Response

Recovery

Improve

Próximos Passos

Tópicos Relacionados

Dica Pro: Use feature flags para separar deploy de release e permitir rollback rápido em caso de problemas.

Links e Referências

Glossário Git

A

Add

Comando usado para adicionar arquivos ao staging area.

Amend

Modificar o último commit realizado.

B

Branch

Ramificação independente de desenvolvimento.

Blame

Comando para mostrar quem modificou cada linha de um arquivo.

C

Cherry-pick

Aplicar mudanças específicas de um commit em outro branch.

Commit

Salvar alterações no repositório com uma mensagem descritiva.

Clone

Criar uma cópia local de um repositório remoto.

D

Diff

Mostrar diferenças entre commits, branches ou arquivos.

Detached HEAD

Estado onde HEAD aponta diretamente para um commit.

F

Fetch

Baixar objetos e refs de outro repositório.

Fork

Cópia independente de um repositório.

H

HEAD

Ponteiro para o commit atual em uso.

Hook

Scripts que rodam automaticamente em eventos Git.

I

Index

Área de staging onde mudanças são preparadas.

M

Merge

Combinar mudanças de diferentes branches.

Main/Master

Branch principal do repositório.

O

Origin

Nome padrão para o repositório remoto principal.

P

Pull

Fetch + Merge de mudanças remotas.

Push

Enviar commits locais para repositório remoto.

R

Rebase

Reescrever histórico movendo ou combinando commits.

Remote

Repositório hospedado em servidor.

Repository

Coleção de commits, refs e objetos.

S

Stash

Armazenar temporariamente mudanças não commitadas.

Submodule

Repositório Git dentro de outro repositório.

T

Tag

Referência para um commit específico.

W

Working Directory

Diretório local onde os arquivos são editados.

Workflow

Fluxo de trabalho definido para uso do Git.

Recursos Git

Documentação Oficial

Git SCM

Plataformas de Hospedagem

GitHub

GitLab

Bitbucket

Ferramentas de Aprendizado

Interativos

Visualizadores

Cursos Online

Gratuitos

Pagos

Comunidade

Fóruns

Blogs

Ferramentas

GUIs

Extensões

Livros Recomendados

Para Iniciantes

  • "Pro Git" por Scott Chacon e Ben Straub

  • "Git in Practice" por Mike McQuaid

Avançados

  • "Git Internals" por Scott Chacon

  • "Git for Teams" por Emma Jane Hogbin Westby

Git Cheat Sheet

Configuração Inicial

# Configurar nome e email
git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

# Configurar editor padrão
git config --global core.editor "code --wait"

Comandos Básicos

Iniciar e Clonar

# Iniciar novo repositório
git init

# Clonar repositório existente
git clone <url>

Mudanças Básicas

# Ver status
git status

# Adicionar arquivos
git add <arquivo>
git add .

# Commit
git commit -m "mensagem"

# Ver histórico
git log
git log --oneline

Branches

# Listar branches
git branch

# Criar branch
git branch <nome>

# Mudar branch
git checkout <nome>
git switch <nome>

# Criar e mudar
git checkout -b <nome>

Sincronização

# Atualizar remoto
git fetch

# Baixar e mesclar
git pull

# Enviar mudanças
git push origin <branch>

Operações Intermediárias

Stash

# Guardar mudanças
git stash

# Listar stashes
git stash list

# Aplicar stash
git stash apply
git stash pop

Merge

# Mesclar branch
git merge <branch>

# Abortar merge
git merge --abort

Rebase

# Rebase interativo
git rebase -i HEAD~3

# Continuar rebase
git rebase --continue

# Abortar rebase
git rebase --abort

Operações Avançadas

Reset e Revert

# Reset soft
git reset --soft HEAD~1

# Reset hard
git reset --hard HEAD~1

# Reverter commit
git revert <commit>

Cherry-pick

# Aplicar commit específico
git cherry-pick <commit>

Submodules

# Adicionar submodule
git submodule add <url>

# Inicializar submodules
git submodule init
git submodule update

Dicas e Truques

Aliases Úteis

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status

Busca Avançada

# Buscar em commits
git log --grep="termo"

# Buscar em arquivos
git grep "termo"

Manutenção

# Limpar arquivos não rastreados
git clean -df

# Compactar repositório
git gc

# Verificar integridade
git fsck

Resolução de Problemas

Conflitos

# Ver arquivos em conflito
git diff --name-only --diff-filter=U

# Abortar merge com conflito
git merge --abort

Recuperação

# Recuperar commit deletado
git reflog
git checkout -b recovery-branch <commit>

Debug

# Encontrar bug
git bisect start
git bisect bad
git bisect good <commit>

Contribuindo para o Git Pie 🤝

Antes de Começar

Antes de fazer uma contribuição, certifique-se de:

  1. Verificar se já não existe uma Issue similar

  2. Ler nosso Código de Conduta

  3. Entender nossas diretrizes de contribuição

Como Contribuir

1. Preparando o Ambiente

# Clone o repositório
git clone https://github.com/seu-usuario/git-pie.git

# Entre no diretório
cd git-pie

# Instale as dependências
npm install

2. Criando uma Nova Feature

# Crie uma nova branch
git checkout -b feature/nova-funcionalidade

# Faça suas alterações
# ...

# Commit das mudanças
git commit -m "feat: adiciona nova funcionalidade"

# Push para seu fork
git push origin feature/nova-funcionalidade

3. Submetendo Alterações

Clone

Branch

Commit

Pull Request

Merge

Fork

Local

Desenvolvimento

Push

Review

Upstream

Tipos de Contribuição

1. Documentação 📚

  • Correções de texto

  • Melhorias na explicação

  • Novos exemplos

  • Traduções

2. Código 💻

  • Novos recursos

  • Correções de bugs

  • Melhorias de performance

  • Testes

3. Design 🎨

  • Melhorias no layout

  • Novos diagramas

  • Imagens e ilustrações

  • Temas e estilos

Diretrizes

Commits

Seguimos o padrão Conventional Commits:

feat: nova funcionalidade
fix: correção de bug
docs: atualização de documentação
style: formatação de código
refactor: refatoração de código
test: adição/modificação de testes
chore: alterações em arquivos de build

Pull Requests

Seu PR deve incluir:

  • Descrição clara das mudanças

  • Screenshots (se aplicável)

  • Referência a Issues relacionadas

  • Checklist de alterações

Código

  • Siga o estilo de código do projeto

  • Adicione testes quando necessário

  • Mantenha a documentação atualizada

  • Evite alterações não relacionadas

Processo de Review

  1. Verificação automatizada

  2. Review por mantenedores

  3. Feedback e ajustes

  4. Aprovação e merge

Reconhecimento

Todos os contribuidores são reconhecidos em nosso arquivo CONTRIBUTORS.md e na documentação do projeto.

Precisa de Ajuda?

  • Abra uma Issue

  • Entre em contato com os mantenedores

  • Participe de nossas discussões

Próximos Passos: Veja nossa para encontrar algo para trabalhar.